Generierte Dokumentation der praktischen Arbeit von Simon Tiffert

Hauptseite | Pakete | Klassenhierarchie | Alphabetische Liste | Auflistung der Klassen | Auflistung der Dateien | Klassen-Elemente

# main.Main Klassenreferenz

Zusammengehörigkeiten von main.Main:

[Legende]
Aufstellung aller Elemente

## Ausführliche Beschreibung

Diese Klasse steuert den Ablauf des Programms.

Hier kann man in der main-Funktion den Ablauf des EVA Prinzips erkennen. Da hier auch zentral Fehler abgefangen werden, war es nötig, die Ausgabedatei schon sehr früh im Programmablauf zu öffnen, da Exceptions sonst nicht in Datei geschrieben werden könnten. In dieser Klasse befindet sich auch das zentrale Matrix-Element, welches per Referenz an die Unterteile Eingabe, Verarbeitung und Ausgabe übergeben wird.
Zudem befindet sich hier der Parser für die Eingabeparameter. Dieser sorgt dafür, dass wichtige Flags in dieser Klasse gesetzt sind. Abgefangen werden:

- -d DATEINAME (erkennt den Parameter und setzt den Dateinamen)

- -debug (setzt das Programm in den Debugmodus, bei dem die Ausgaben auch auf dem Bildschirm ausgegeben werden).

- -overwrite (überschreibt eine vorhandene Ausgabedatei. Dies erleichtert das Testen, kann aber im normalen Ablauf unerwünscht sein)

- -h (zeigt die Hilfe an, wie das Programm aufgerufen wird. Die Hilfe wird auch automatisch angezeigt, wenn Parameter falsch angegeben wurden)

Version:
  Revision
    1.16

Autor:
  Simon Tiffert

Definiert in Zeile 68 der Datei Main.java.

## Öffentliche, statische Methoden
void | main (String[] args)
| main-Funktion des Programms.
## Statische öffentliche Attribute
final int | maxDimension = 6
| maximale Größe der Matrix
boolean | debug = false
| setzt den Debug-Modus
boolean | overwrite = false
| setzt den Overwrite-Modus
Matrix | matrix = new Matrix()
| Die zentrale Datenstruktur mit der Matrix.
## Private, statische Methoden
String | parameterParser (String[] parameter) throws WrongParameterException, NoInputException
| Diese Funktion parst die Eingabeparameter.

## Dokumentation der Elementfunktionen

void main.Main.main | ( | String[] | args | ) | `[static]`

  | main-Funktion des Programms. Hier wird die Verarbeitung des Programms gesteuert und die Fehlerabfrage durchgeführt, die zur weiteren Verarbeitung weitergereicht wird. Parameter:
  args | Programmparameter -d DATEINAME [-h] [-debug][-overwrite]
Definiert in Zeile 91 der Datei Main.java. Benutzt main.Main.parameterParser().
    00092   {
    00093     // Dateiname der Eingabedatei
    00094     String dateiName = null;
    00095
    00096     // Erstelle einen Writer, für die Ausgabedatei
    00097     BufferedWriter bw = null;
    00098
    00099     try
    00100     {
    00101       // Überprüft, ob ein Dateiname mit angegeben wurde.
    00102       dateiName = parameterParser(args);
    00103
    00104       // öffne Ausgabedatei und setze den Writer darauf
    00105       bw = new OutputFile(dateiName, ".out").getAusgabeDatei();
    00106
    00107       // EVA-Prinzip:
    00108
    00109       // Erstelle eine Instanz der Eingabe
    00110       new Eingabe(matrix, dateiName);
    00111
    00112       // rufe die Verarbeitung mit den RoesselSprüngen auf
    00113       new Verarbeitung(matrix);
    00114
    00115       // erzeuge die Ausgabe
    00116       new Ausgabe(matrix, bw);
    00117
    00118     }
    00119     catch (Exception e)
    00120     {
    00121       // die Fehler werden dann in der Datei ausgewertet
    00122       new FehlerAusgabe(bw, e, dateiName);
    00123     }
    00124     finally
    00125     {
    00126       // schliesse die Ausgabedatei und fange einen Fehler dabei auf
    00127       try
    00128       {
    00129         if (bw != null)
    00130         {
    00131           bw.close();
    00132         }
    00133       }
    00134       catch (IOException e)
    00135       {
    00136         System.err.println(
    00137           "Ausgabedatei konnte nicht geschrieben werden.");
    00138       }
    00139     }
    00140
    00141   }

Hier ist der Graph aller Aufrufe für diese Funktion:

String main.Main.parameterParser | ( | String[] | parameter | ) | throws WrongParameterException, NoInputException `[static, private]`

  | Diese Funktion parst die Eingabeparameter. Dabei wird überprüft, ob eine Eingabedatei angegeben wurde. Zudem werden weitere Parameter erkannt und fehlerhafte sowie doppelte Parameter werden erkannt und als Exception geworfen. <br /> Erkannt werden: -d DATEINAME (Pflichtparameter) -h (Hilfe) -debug (Debugmodus) -overwrite (Overwrite-Modus, der die Ausgabedatei überschreibt) Parameter:
  parameter | Übergabeparameter der main-Funktion
  Rückgabe: Übergebenen Dateinamen Ausnahmebehandlung:
  WrongParameterException | Fehlerhafte Parameter
  NoInputException | Fehlende Parameter
Definiert in Zeile 164 der Datei Main.java. Benutzt main.Main.debug und main.Main.overwrite. Wird benutzt von main.Main.main().
    00166   {
    00167     // Dateiname der Eingabedatei
    00168     String dateiName = null;
    00169
    00170     // Flagge für Anzeige der Hilfe
    00171     boolean hilfe = false;
    00172
    00173     // überprüft, ob überhaupt Parameter angegeben wurden
    00174     if (parameter.length == 0)
    00175     {
    00176       // werfe eigene Exception
    00177       throw new NoInputException();
    00178     }
    00179
    00180     // laufe über alle Parameter
    00181     for (int i = 0; i < parameter.length; i++)
    00182     {
    00183       // -d für Dateiname
    00184       if (parameter[i].equalsIgnoreCase("-d"))
    00185       {
    00186         // wenn der Dateiname noch nicht gesetzt ist
    00187         if (dateiName == null)
    00188         {
    00189           // setze den nächsten Parameter als Dateinamen, wenn noch
    00190           // Parameter vorhanden sind. Ansonsten werfe Fehler, dass
    00191           // der Dateiname fehlt
    00192           if (i < parameter.length - 1)
    00193           {
    00194             dateiName = parameter[++i];
    00195           }
    00196           else
    00197           {
    00198             throw new WrongParameterException(
    00199               "Falscher Parameter - Dateiname fehlt");
    00200           }
    00201
    00202           // Falls danach wieder ein Parameter folgt, fehlt der
    00203           // Dateiname
    00204           if (dateiName.startsWith("-"))
    00205           {
    00206             throw new WrongParameterException(
    00207               "Falscher Parameter - Dateiname fehlt");
    00208           }
    00209         }
    00210         // wenn der Dateiname schon gesetzt ist, wäre er doppelt
    00211         // definiert. Um Fehlern vorzubeugen wird hier eine Exception
    00212         // geworfen
    00213         else
    00214         {
    00215           throw new WrongParameterException(
    00216             "Doppelter Parameter - Dateiname schon angegeben");
    00217         }
    00218       }
    00219
    00220       // -debug Debug-Modus
    00221       else if (parameter[i].equalsIgnoreCase("-debug"))
    00222       {
    00223         // wenn der Debugmodus noch nicht gesetzt ist, setze ihn jetzt
    00224         if (debug == false)
    00225         {
    00226           debug = true;
    00227         }
    00228         // doppelter Parameter, der zu einer Exception führt
    00229         else
    00230         {
    00231           throw new WrongParameterException(
    00232             "Doppelter Parameter -debug");
    00233         }
    00234       }
    00235
    00236       // -overwrite Overwrite-Modus
    00237       else if (parameter[i].equalsIgnoreCase("-overwrite"))
    00238       {
    00239         // Wenn der Overwritemodus noch nicht gesetzt ist, setze ihn
    00240         // jetzt
    00241         if (overwrite == false)
    00242         {
    00243           overwrite = true;
    00244         }
    00245         // doppelter Parameter, der zu einer Exception führt
    00246         else
    00247         {
    00248           throw new WrongParameterException(
    00249             "Doppelter Parameter -overwrite");
    00250         }
    00251       }
    00252
    00253       // -h Hilfe
    00254       else if (parameter[i].equalsIgnoreCase("-h"))
    00255       {
    00256         // überprüfe, ob die Hilfe schon angezeigt werden soll.
    00257         // Ansonsten setze Flag zur Anzeige
    00258         if (hilfe == false)
    00259         {
    00260           hilfe = true;
    00261         }
    00262         // doppelter Parameter, der zu einer Exception führt
    00263         else
    00264         {
    00265           throw new WrongParameterException("Doppelter Parameter -h");
    00266         }
    00267       }
    00268
    00269       // unbekannter Parameter, der zu einer Exception führt
    00270       else
    00271       {
    00272         throw new WrongParameterException(
    00273           "Fehlerhafter Parameter - " + parameter[i]);
    00274       }
    00275
    00276     }
    00277
    00278     // wenn die Hilfe angezeigt werden soll, so unterbreche den
    00279     // Programmfluss mit einer Exception, die allerdings keinen Fehler
    00280     // erzeugt, sondern die Hilfe anzeigt
    00281     if (hilfe == true)
    00282     {
    00283       throw new WrongParameterException("");
    00284     }
    00285     // ist der Dateiname noch nicht gesetzt worden, so ist keine
    00286     // weitere Verarbeitung möglich und das Programm wird mit einer
    00287     // Exception abgebrochen
    00288     else if (dateiName == null)
    00289     {
    00290       throw new WrongParameterException(
    00291         "Falscher Aufruf - keine Eingabedatei angegeben");
    00292     }
    00293
    00294     // wenn alles richtig verarbeitet wurde, gib den Dateinamen zurück
    00295     return dateiName;
    00296   }

## Dokumentation der Datenelemente

boolean main.Main.debug = false`[static]`

| setzt den Debug-Modus Definiert in Zeile 74 der Datei Main.java. Wird benutzt von main.Main.parameterParser().

Matrix main.Main.matrix = new Matrix()`[static]`

| Die zentrale Datenstruktur mit der Matrix. Definiert in Zeile 80 der Datei Main.java.

final int main.Main.maxDimension = 6`[static]`

| maximale Größe der Matrix Definiert in Zeile 71 der Datei Main.java.

boolean main.Main.overwrite = false`[static]`

| setzt den Overwrite-Modus Definiert in Zeile 77 der Datei Main.java. Wird benutzt von main.Main.parameterParser().

Die Dokumentation für diese Klasse wurde erzeugt aufgrund der Datei:

- Main.java

Documentation created with Doxygen 1.3.6 | Fri May 14 11:15:33 2004