From 200715c547c6a5a613f8f528874217a232d0ae46 Mon Sep 17 00:00:00 2001 From: Milan Lukic <2122158@stud.hs-mannheim.de> Date: Tue, 3 Jan 2023 12:13:16 +0100 Subject: [PATCH] Initial Commit --- Roboterfabrik/.classpath | 10 +++ Roboterfabrik/.gitignore | 1 + Roboterfabrik/.project | 17 +++++ .../org.eclipse.core.resources.prefs | 2 + .../.settings/org.eclipse.jdt.core.prefs | 14 ++++ .../src/tpe/exceptions/roboter/Robot.java | 11 +++ .../tpe/exceptions/roboter/RobotControl.java | 74 +++++++++++++++++++ .../exceptions/roboter/RobotInstructions.java | 49 ++++++++++++ 8 files changed, 178 insertions(+) create mode 100644 Roboterfabrik/.classpath create mode 100644 Roboterfabrik/.gitignore create mode 100644 Roboterfabrik/.project create mode 100644 Roboterfabrik/.settings/org.eclipse.core.resources.prefs create mode 100644 Roboterfabrik/.settings/org.eclipse.jdt.core.prefs create mode 100644 Roboterfabrik/src/tpe/exceptions/roboter/Robot.java create mode 100644 Roboterfabrik/src/tpe/exceptions/roboter/RobotControl.java create mode 100644 Roboterfabrik/src/tpe/exceptions/roboter/RobotInstructions.java diff --git a/Roboterfabrik/.classpath b/Roboterfabrik/.classpath new file mode 100644 index 0000000..ac9ce57 --- /dev/null +++ b/Roboterfabrik/.classpath @@ -0,0 +1,10 @@ + + + + + + + + + + diff --git a/Roboterfabrik/.gitignore b/Roboterfabrik/.gitignore new file mode 100644 index 0000000..ae3c172 --- /dev/null +++ b/Roboterfabrik/.gitignore @@ -0,0 +1 @@ +/bin/ diff --git a/Roboterfabrik/.project b/Roboterfabrik/.project new file mode 100644 index 0000000..7296e1e --- /dev/null +++ b/Roboterfabrik/.project @@ -0,0 +1,17 @@ + + + Roboterfabrik + + + + + + org.eclipse.jdt.core.javabuilder + + + + + + org.eclipse.jdt.core.javanature + + diff --git a/Roboterfabrik/.settings/org.eclipse.core.resources.prefs b/Roboterfabrik/.settings/org.eclipse.core.resources.prefs new file mode 100644 index 0000000..4824b80 --- /dev/null +++ b/Roboterfabrik/.settings/org.eclipse.core.resources.prefs @@ -0,0 +1,2 @@ +eclipse.preferences.version=1 +encoding/=UTF-8 diff --git a/Roboterfabrik/.settings/org.eclipse.jdt.core.prefs b/Roboterfabrik/.settings/org.eclipse.jdt.core.prefs new file mode 100644 index 0000000..dbc27c5 --- /dev/null +++ b/Roboterfabrik/.settings/org.eclipse.jdt.core.prefs @@ -0,0 +1,14 @@ +eclipse.preferences.version=1 +org.eclipse.jdt.core.compiler.codegen.inlineJsrBytecode=enabled +org.eclipse.jdt.core.compiler.codegen.targetPlatform=17 +org.eclipse.jdt.core.compiler.codegen.unusedLocal=preserve +org.eclipse.jdt.core.compiler.compliance=17 +org.eclipse.jdt.core.compiler.debug.lineNumber=generate +org.eclipse.jdt.core.compiler.debug.localVariable=generate +org.eclipse.jdt.core.compiler.debug.sourceFile=generate +org.eclipse.jdt.core.compiler.problem.assertIdentifier=error +org.eclipse.jdt.core.compiler.problem.enablePreviewFeatures=disabled +org.eclipse.jdt.core.compiler.problem.enumIdentifier=error +org.eclipse.jdt.core.compiler.problem.reportPreviewFeatures=warning +org.eclipse.jdt.core.compiler.release=enabled +org.eclipse.jdt.core.compiler.source=17 diff --git a/Roboterfabrik/src/tpe/exceptions/roboter/Robot.java b/Roboterfabrik/src/tpe/exceptions/roboter/Robot.java new file mode 100644 index 0000000..5358b2b --- /dev/null +++ b/Roboterfabrik/src/tpe/exceptions/roboter/Robot.java @@ -0,0 +1,11 @@ +/* (c) 2012 Thomas Smits */ +package tpe.exceptions.roboter; + +/** + * Interface für Roboter. + * + * @author Thomas Smits + */ +public interface Robot extends RobotControl, RobotInstructions { + // keine eigenen Methoden +} diff --git a/Roboterfabrik/src/tpe/exceptions/roboter/RobotControl.java b/Roboterfabrik/src/tpe/exceptions/roboter/RobotControl.java new file mode 100644 index 0000000..814f272 --- /dev/null +++ b/Roboterfabrik/src/tpe/exceptions/roboter/RobotControl.java @@ -0,0 +1,74 @@ +package tpe.exceptions.roboter; + +import tpe.exceptions.roboter.exceptions.RobotException; + +/** + * Das Interface repräsentiert einen einfachen Roboter mit seinen Funktionen. + * + * Jeder produzierte Roboter hat einen Namen, der vom Besteller frei gewählt + * werden kann. Der Name bleibt über die gesamte Lebensdauer des Roboters + * unveränderlich. Man kann einen Roboter jederzeit über die + * getName()-Methode nach seinem Namen fragen. + * + * Zusätzlich zum frei gewählten Namen, hat jeder Roboter noch eine + * Seriennummer. Diese wird bei der Produktion festgelegt und hat einen vom + * Roboter-Typ abhängigen Bereich möglicher Werte. Innerhalb des Bereiches wird + * die Seriennummer zufällig vergeben. Die Seriennummer kann auch bei + * ausgeschalteten Roboter über getId()gelesen werden. + * + * Ein Roboter hat einen Hauptschalter, der mithilfe der + * triggerPowerSwitch()-Methode bedient werden kann. Direkt nach + * der Produktion ist der Roboter ausgeschaltet. Drückt man einmal auf den + * Schalter, wird er eingeschaltet. Ein weiterer Druck schaltet ihn wieder aus, usw. + * + * Die aktuelle Position des Hauptschalters kann man mit der Methode + * isPowerOn() abfragen. Hierbei bedeutet true, dass + * der Roboter eingeschaltet ist und false, dass er nicht + * eingeschaltet ist. + * + * Falls ein Fehler auftritt, kann der Nutzer des Roboters den letzten + * aufgetretenen Fehler über eine Blackbox (Fehlerspeicher) auslesen. Dies + * geschieht mithilfe der getLastException()-Methode. Der + * Fehlerspeicher kann auch bei ausgeschaltetem Roboter benutzt werden. Gab es + * noch keinen Fehler, ist der Fehlerspeicher leer (null). + * + * Alle Methoden dieses Interfaces können auch auf einem Roboter aufgerufen + * werden, der ausgeschaltet ist (d.h. wenn isPowerOn() == false). + */ +public interface RobotControl { + + /** + * Gibt die ID (Seriennummer) des Roboters zurück. + * + * @return Eine eindeutige Identifikation in Form einer Zahl. + */ + public int getId(); + + /** + * Gibt den Namen des Roboter-Exemplars zurück. + * + * @return Der Name des Roboters. + */ + public String getName(); + + /** + * Betätigen den An-/Ausschaltknopf. + */ + public void triggerPowerSwitch(); + + /** + * Prüft ob der Roboter eingeschaltet ist. + * + * @return true bedeutet, dass der Roboter eingeschaltet ist, + * false, dass er nicht eingeschaltet ist. + */ + public boolean isPowerOn(); + + /** + * Ruft die zuletzt aufgetretene Ausnahme aus der Blackbox ab. + * + * @return zuletzt aufgetretene Ausnahme oder null falls noch + * keine aufgetreten ist. + */ + public RobotException getLastException(); +} \ No newline at end of file diff --git a/Roboterfabrik/src/tpe/exceptions/roboter/RobotInstructions.java b/Roboterfabrik/src/tpe/exceptions/roboter/RobotInstructions.java new file mode 100644 index 0000000..9426eb9 --- /dev/null +++ b/Roboterfabrik/src/tpe/exceptions/roboter/RobotInstructions.java @@ -0,0 +1,49 @@ +package tpe.exceptions.roboter; + +import tpe.exceptions.roboter.exceptions.RobotException; +import tpe.exceptions.roboter.exceptions.RobotIllegalStateException; +import tpe.exceptions.roboter.exceptions.RobotMagicValueException; + +/** + * Das Interface repräsentiert den Befehlssatz eines einfachen Roboters. + * + * Jeder Roboter kann zwei grundlegende Operationen durchführen: das Umwandeln + * einer Menge von Zahlen in einen String (speak(...)) und das + * sortieren eines Arrays von Zahlen (think(...)). Wie genau das + * Sortieren oder die Umwandlung erfolgt, hängt vom jeweiligen Typ des Roboters ab. + * + * Zu beachten ist, dass die Methoden dieses Interfaces nur auf Robotern benutzt + * werden können, die eingeschaltet sind. Versucht man sie auf einem + * ausgeschalteten Roboter zu benutzen, werfen sie eine {@link RobotIllegalStateException}. + * + * Weiterhin haben alle Roboter einen kleinen technischen Defekt, der dazu führt + * dass die Methoden dieses Interfaces abstürzen, wenn in den Eingabedaten ein + * spezieller Wert vorkommt. Immer wenn (speak(...)) oder ( + * think(...)) mit einem Array aufgerufen werden, das irgendwo die + * Zahl {@literal 42} enthält, verweigern sie ihren Dienst und werfen eine + * {@link RobotMagicValueException}. + */ +public interface RobotInstructions { + + /** + * Gibt ein Array von Zahlen als String zurück. Die Zahlen werden + * nicht sortiert. + * + * @param zahlen Zahlen, die ausgegeben werden sollen. + * @return Zahlen als String + * @throws RobotException wenn der Roboter in einem ungültigen Zustand ist, + * oder das Array nicht seinen Vorstellungen entspricht. + */ + public String speak(int[] zahlen) throws RobotException; + + /** + * Sortiert ein Array von Zahlen. Die Reihenfolge hängt von dem Typ des + * Roboters ab. + * + * @param zahlen Zahlen, die sortiert werden sollen. + * @return Sortierte Zahlen + * @throws RobotException wenn der Roboter in einem ungültigen Zustand ist, + * oder das Array nicht seinen Vorstellungen entspricht. + */ + public int[] think(int[] zahlen) throws RobotException; +}