Generierte Dokumentation der praktischen Arbeit von Simon Tiffert

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

# main.ausgabe.FehlerAusgabe Klassenreferenz

Zusammengehörigkeiten von main.ausgabe.FehlerAusgabe:

[Legende]
Aufstellung aller Elemente

## Ausführliche Beschreibung

Klasse, die zur Verarbeitung und Ausgabe von Fehlern dient.

Dabei bekommt die Klasse ein Objekt des Typs Exception übergeben, welches dann genauer untersucht wird und eine hier definierte Ausgabe auf Datei bzw. im Debugmodus auch auf dem Bildschirm ausgegeben wird. Folgende Exceptions werden untersucht:

UnexpectedCharacterException
  Zeilenlänge überschritten
UnexpectedLineException
  Es treten noch Zeichen am Zeilenende auf
UnknownCharacterException
  Es ist ein unbekanntes Zeichen in der Eingabe aufgetreten
TooFewCharactersException
  Es sind zuwenig Zeichen in der Zeile angegeben
TooFewSperrfelderException
  Es sind zuwenig Sperrfelder angegeben
WrongDimensionException
  Falsche Dimensionsangaben für Matrix
OutOfMatrixException
  Punkt außerhalb der Matrix
IsStartpunktException
  Sperrfeld soll auf Startpunkt gesetzt werden
IsSperrfeldException
  Doppelte Definition eines Sperrfelds
NoWayFoundException
  Die Rekursion war nicht erfolgreich
FileNotFoundException
  Eingabedatei wurde nicht gefunden
OutputFileExistsException
  Ausgabedatei existiert bereits (ohne -overwrite)
WrongParameterException
  Falsche Eingabe der Programmparameter
IOException
  Fehler bei der Ausgabe
Exception
  Der Defaultfall, der unerwartete Fehler auffängt

Version:
  Revision
    1.7

Autor:
  Simon Tiffert

Definiert in Zeile 84 der Datei FehlerAusgabe.java.

## Öffentliche Methoden
| FehlerAusgabe (BufferedWriter bw, Exception exception, String dateiName)
| Der Konstruktor sorgt dafür, dass der Fehler verarbeitet wird und das Attribut eingabeDateiName gesetzt wird.
## Paketattribute
String | eingabeDateiName
| Name der Eingabedatei, um diese im Fehlerfall mit auszugeben.
BufferedWriter | bw
| BufferedWriter der Ausgabedatei.
Exception | exception
| Exception, die genauer untersucht wird.
## Private Methoden
void | printError ()
| Diese Funktion dient der Auswertung von Fehlern, die im Programmablauf passieren können.
void | schreibeFehler (String s)
| Diese Funktion schreibt den gefundenen Fehler in die Ausgabedatei und fängt einen eventuellen Fehler ab.
## Private, statische Methoden
void | hilfeAusgabe ()
| Diese Funktion erzeugt die Hilfeausgabe, die angezeigt wird, wenn das Programm falsch aufgerufen wurde oder wenn der Parameter -h eingegeben wurde.

## Beschreibung der Konstruktoren und Destruktoren

main.ausgabe.FehlerAusgabe.FehlerAusgabe | ( | BufferedWriter | bw,
|  | Exception | exception,
|  | String | dateiName
| ) |

  | Der Konstruktor sorgt dafür, dass der Fehler verarbeitet wird und das Attribut eingabeDateiName gesetzt wird. Parameter:
  bw | BufferedWriter der Ausgabedatei
  exception | Exception, die genauer untersucht wird
  dateiName | Name der Eingabedatei
Definiert in Zeile 103 der Datei FehlerAusgabe.java. Benutzt main.ausgabe.FehlerAusgabe.eingabeDateiName und main.ausgabe.FehlerAusgabe.printError().
    00107   {
    00108     // BufferedWriter der Ausgabedatei
    00109     this.bw = bw;
    00110
    00111     // Exception, die zu untersuchen ist
    00112     this.exception = exception;
    00113
    00114     // Name der Eingabedatei, die im Fehlerfall ausgegeben wird
    00115     eingabeDateiName = dateiName;
    00116
    00117     // Aufruf der Ausgabefunktion
    00118     printError();
    00119   }

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

## Dokumentation der Elementfunktionen

void main.ausgabe.FehlerAusgabe.hilfeAusgabe | ( |  | ) | `[static, private]`

| Diese Funktion erzeugt die Hilfeausgabe, die angezeigt wird, wenn das Programm falsch aufgerufen wurde oder wenn der Parameter -h eingegeben wurde. Definiert in Zeile 323 der Datei FehlerAusgabe.java. Wird benutzt von main.ausgabe.FehlerAusgabe.printError().
    00324   {
    00325     // Einfache formatierte Ausgabe
    00326     System.out.println(
    00327       "Aufruf:\n"
    00328         + "java -jar programm.jar -d Datei [-h][-debug][-overwrite]"
    00329         + "\n\n"
    00330         + "-h         zeigt diese Hilfe an\n"
    00331         + "-debug     die Fehlerausgabe wird zusätzlich auf dem"
    00332         + "  Bildschirm ausgeben\n"
    00333         + "-overwrite eine vorhandene Ausgabedatei mit gleichem Namen "
    00334         + " wird überschrieben\n");
    00335   }

void main.ausgabe.FehlerAusgabe.printError | ( |  | ) | `[private]`

| Diese Funktion dient der Auswertung von Fehlern, die im Programmablauf passieren können. Dabei wird eine Unterteilung in Fehlerklassen vorgenommen. Definiert in Zeile 127 der Datei FehlerAusgabe.java. Benutzt main.ausgabe.FehlerAusgabe.exception, main.ausgabe.FehlerAusgabe.hilfeAusgabe() und main.ausgabe.FehlerAusgabe.schreibeFehler(). Wird benutzt von main.ausgabe.FehlerAusgabe.FehlerAusgabe().
    00128   {
    00129     // Programmfehler
    00130     if (exception instanceof UnexpectedCharacterException)
    00131     {
    00132       // Zeilenlänge überschritten
    00133       schreibeFehler(
    00134         "Zuviel Eingaben in Zeile " + exception.getMessage());
    00135     }
    00136     else if (exception instanceof UnexpectedLineException)
    00137     {
    00138       // Es treten noch Zeichen am Dateiende auf
    00139       schreibeFehler(
    00140         "Es folgen noch Zeichen nach der Eingabe in Zeile "
    00141           + exception.getMessage());
    00142     }
    00143     else if (exception instanceof UnknownCharacterException)
    00144     {
    00145       // Es ist ein unbekanntes Zeichen in der Eingabe aufgetreten
    00146       schreibeFehler(
    00147         "Unbekanntes Zeichen in der Eingabe in Zeile "
    00148           + exception.getMessage());
    00149     }
    00150     else if (exception instanceof TooFewCharactersException)
    00151     {
    00152       // Zuwenig Zeichen für die Matrix
    00153       schreibeFehler(
    00154         "Zu wenig Zeichen für Eingabe in Zeile "
    00155           + exception.getMessage());
    00156     }
    00157     else if (exception instanceof TooFewSperrfelderException)
    00158     {
    00159       // Zuwenig Zeichen für die Matrix
    00160       schreibeFehler("Es sind zu wenige Sperrfelder angegeben");
    00161     }
    00162     else if (exception instanceof WrongDimensionException)
    00163     {
    00164       // Falsche Dimensionsangabe für Matrix
    00165       schreibeFehler("Falsche Dimensionsangaben für Matrix");
    00166     }
    00167     else if (exception instanceof OutOfMatrixException)
    00168     {
    00169       // Punkt außerhalb der Matrix definiert
    00170       schreibeFehler(
    00171         exception.getMessage() + " außerhalb der Matrix definiert");
    00172     }
    00173     else if (exception instanceof IsStartpunktException)
    00174     {
    00175       // Sperrfeld auf Startpunkt definiert
    00176       schreibeFehler(
    00177         "Sperrfeld auf Startpunkt"
    00178           + exception.getMessage()
    00179           + " definiert");
    00180     }
    00181     else if (exception instanceof IsSperrfeldException)
    00182     {
    00183       // Sperrfeld doppelt definiert
    00184       schreibeFehler(
    00185         "Sperrfeld " + exception.getMessage() + " doppelt definiert");
    00186     }
    00187     // Fehler, die nicht in Datei geschrieben werden können
    00188     else if (exception instanceof FileNotFoundException)
    00189     {
    00190       // Die Eingabedatei wurde nicht gefunden
    00191       System.out.println("Die Eingabedatei wurde nicht gefunden");
    00192     }
    00193     else if (exception instanceof OutputFileExistsException)
    00194     {
    00195       // Ausgabedatei existiert schon, somit muss die Fehlermeldung auf
    00196       // dem Bildschirm erscheinen
    00197       System.out.println(
    00198         "Die Datei " + exception.getMessage() + " existiert schon");
    00199     }
    00200     else if (exception instanceof NoInputException)
    00201     {
    00202       System.out.println(
    00203         "Es wurde kein Parameter für das Programm übergeben.");
    00204       hilfeAusgabe();
    00205     }
    00206     else if (exception instanceof WrongParameterException)
    00207     {
    00208       System.out.println(exception.getMessage());
    00209       hilfeAusgabe();
    00210     }
    00211     // Fehler die nicht in den vorherigen Routinen behandelt wurden
    00212     else if (exception instanceof IOException)
    00213     {
    00214       // Fehler konnte nicht in die Datei geschrieben werden
    00215       schreibeFehler(
    00216         "Es ist ein Fehler bei der Ausgabe aufgetreten:"
    00217           + exception.getMessage());
    00218     }
    00219     else
    00220     {
    00221       // Allgemeiner Fehler
    00222       schreibeFehler(
    00223         "Es ist ein Fehler aufgetreten: " + exception.getMessage());
    00224     }
    00225   }

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

void main.ausgabe.FehlerAusgabe.schreibeFehler | ( | String | s | ) | `[private]`

  | Diese Funktion schreibt den gefundenen Fehler in die Ausgabedatei und fängt einen eventuellen Fehler ab. Zudem ist hier noch eine Debugausgabe implementiert, die den Fehler zusätzlich noch auf dem Bildschirm ausgibt Parameter:
  s | Der Text der in die Ausgabedatei geschrieben wird
Definiert in Zeile 235 der Datei FehlerAusgabe.java. Benutzt main.ausgabe.FehlerAusgabe.bw und main.ausgabe.FehlerAusgabe.eingabeDateiName. Wird benutzt von main.ausgabe.FehlerAusgabe.printError().
    00236   {
    00237     // Hier wird die Ausgabe zusammengebaut
    00238     StringBuffer eingabe = new StringBuffer("");
    00239
    00240     // Zeilenumbruch nach Betriebssystem anpassen
    00241     String lineEnd = System.getProperty("line.separator");
    00242
    00243     //  Falls dies scheitert, setze Standard Zeilenumbruch
    00244     if (lineEnd == null)
    00245     {
    00246       lineEnd = "\n";
    00247     }
    00248
    00249     // Tabulator
    00250     String tabulator = "    ";
    00251
    00252     // gib die Eingabedati nochmal aus, wenn es möglich ist
    00253     try
    00254     {
    00255       // Öffne die Eingabedatei
    00256       LineNumberReader line =
    00257         new LineNumberReader(
    00258           new FileReader(
    00259             new File(eingabeDateiName)));
    00260
    00261       // Header vor Eingabedatei
    00262       eingabe.append(lineEnd + tabulator + "Eingabedaten: " + lineEnd);
    00263       eingabe.append(tabulator + "*************" + lineEnd);
    00264
    00265       // Lies die Datei aus und schreibe sie in den StringBuffer
    00266       String zeile;
    00267       while ((zeile = line.readLine()) != null)
    00268       {
    00269         // Sorge dafür, dass Zeilennummern richtig formatiert sind
    00270         String whitespace = "  ";
    00271         if (line.getLineNumber() >= 10)
    00272         {
    00273           whitespace = " ";
    00274         }
    00275
    00276         // Erstelle eine formatierte Zeile
    00277         eingabe.append(
    00278           whitespace
    00279             + line.getLineNumber()
    00280             + ":"
    00281             + tabulator
    00282             + zeile
    00283             + lineEnd);
    00284       }
    00285     }
    00286     // Fange die Exception
    00287     catch (Exception e)
    00288     {
    00289       // Die Eingabedatei konnte nicht gelesen werden, was für manche
    00290       // Fehler charakterisierend ist. Somit kann dieser Fall einfach
    00291       // gefangen werden
    00292     }
    00293
    00294     // Gib den Fehler aus
    00295     try
    00296     {
    00297       // Ist der Debugmodus gesetzt, dann gib die Meldung
    00298       // zusätzlich auf dem Bildschirm aus
    00299       if (Main.debug)
    00300       {
    00301         System.out.println(eingabe + lineEnd + lineEnd);
    00302         System.out.println(tabulator + s);
    00303       }
    00304       // Schreibe in die Ausgabedatei
    00305       bw.write(eingabe + lineEnd + lineEnd);
    00306       bw.write(tabulator + s);
    00307     }
    00308     // Das Schreiben auf Datei war nicht erfolgreich
    00309     catch (Exception e)
    00310     {
    00311       // Gib die Fehlermeldung aus
    00312       System.err.println(
    00313         "Die Ausgabedatei konnte nicht beschrieben werden.");
    00314     }
    00315   }

## Dokumentation der Datenelemente

BufferedWriter main.ausgabe.FehlerAusgabe.bw`[package]`

| BufferedWriter der Ausgabedatei. Definiert in Zeile 90 der Datei FehlerAusgabe.java. Wird benutzt von main.ausgabe.FehlerAusgabe.schreibeFehler().

String main.ausgabe.FehlerAusgabe.eingabeDateiName`[package]`

| Name der Eingabedatei, um diese im Fehlerfall mit auszugeben. Definiert in Zeile 87 der Datei FehlerAusgabe.java. Wird benutzt von main.ausgabe.FehlerAusgabe.FehlerAusgabe() und main.ausgabe.FehlerAusgabe.schreibeFehler().

Exception main.ausgabe.FehlerAusgabe.exception`[package]`

| Exception, die genauer untersucht wird. Definiert in Zeile 93 der Datei FehlerAusgabe.java. Wird benutzt von main.ausgabe.FehlerAusgabe.printError().

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

- FehlerAusgabe.java

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