Generierte Dokumentation der praktischen Arbeit von Simon Tiffert

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

# FehlerAusgabe.java

gehe zur Dokumentation dieser Datei

    00001 /*
    00002  *
    00003  * Datei:   FehlerAusgabe.java
    00004  *
    00005  * ---------------------------------
    00006  *
    00007  * Datum:           $Date: 2004/05/13 10:14:19 $
    00008  * Autor:           Simon Tiffert
    00009  * Prüfungsnummer:  40
    00010  * Firma:           T-Systems
    00011  * eMail-Adresse:   simon.tiffert@t-systems.com
    00012  * Version:         $Revision: 1.7 $
    00013  *
    00014  * ---------------------------------
    00015  *
    00016  */
    00017
    00018 package main.ausgabe;
    00019
    00020 import java.io.BufferedWriter;
    00021 import java.io.File;
    00022 import java.io.FileNotFoundException;
    00023 import java.io.FileReader;
    00024 import java.io.IOException;
    00025 import java.io.LineNumberReader;
    00026
    00027 import main.Main;
    00028 import main.NoInputException;
    00029 import main.WrongParameterException;
    00030 import main.eingabe.TooFewCharactersException;
    00031 import main.eingabe.TooFewSperrfelderException;
    00032 import main.eingabe.UnexpectedCharacterException;
    00033 import main.eingabe.UnexpectedLineException;
    00034 import main.eingabe.UnknownCharacterException;
    00035 import main.tools.file.OutputFileExistsException;
    00036 import main.verarbeitung.IsSperrfeldException;
    00037 import main.verarbeitung.IsStartpunktException;
    00038 import main.verarbeitung.OutOfMatrixException;
    00039 import main.verarbeitung.WrongDimensionException;
    00040
    00041 /**
    00042  * Klasse, die zur Verarbeitung und Ausgabe von Fehlern dient.
    00043  * Dabei bekommt die Klasse ein Objekt des Typs Exception übergeben,
    00044  * welches dann genauer untersucht wird und eine hier definierte
    00045  * Ausgabe auf Datei bzw. im Debugmodus auch auf dem Bildschirm
    00046  * ausgegeben wird.
    00047  * Folgende Exceptions werden untersucht:
    00048  * <dl>
    00049  *  <dt>UnexpectedCharacterException</dt>
    00050  *  <dd>Zeilenlänge überschritten</dd>
    00051  *  <dt>UnexpectedLineException</dt>
    00052  *  <dd>Es treten noch Zeichen am Zeilenende auf</dd>
    00053  *  <dt>UnknownCharacterException</dt>
    00054  *  <dd>Es ist ein unbekanntes Zeichen in der Eingabe aufgetreten</dd>
    00055  *  <dt>TooFewCharactersException</dt>
    00056  *  <dd>Es sind zuwenig Zeichen in der Zeile angegeben</dd>
    00057  *  <dt>TooFewSperrfelderException</dt>
    00058  *  <dd>Es sind zuwenig Sperrfelder angegeben</dd>
    00059  *  <dt>WrongDimensionException</dt>
    00060  *  <dd>Falsche Dimensionsangaben für Matrix</dd>
    00061  *  <dt>OutOfMatrixException</dt>
    00062  *  <dd>Punkt außerhalb der Matrix</dd>
    00063  *  <dt>IsStartpunktException</dt>
    00064  *  <dd>Sperrfeld soll auf Startpunkt gesetzt werden</dd>
    00065  *  <dt>IsSperrfeldException</dt>
    00066  *  <dd>Doppelte Definition eines Sperrfelds</dd>
    00067  *  <dt>NoWayFoundException</dt>
    00068  *  <dd>Die Rekursion war nicht erfolgreich</dd>
    00069  *  <dt>FileNotFoundException</dt>
    00070  *  <dd>Eingabedatei wurde nicht gefunden</dd>
    00071  *  <dt>OutputFileExistsException</dt>
    00072  *  <dd>Ausgabedatei existiert bereits (ohne -overwrite)</dd>
    00073  *  <dt>WrongParameterException</dt>
    00074  *  <dd>Falsche Eingabe der Programmparameter</dd>
    00075  *  <dt>IOException</dt>
    00076  *  <dd>Fehler bei der Ausgabe</dd>
    00077  *  <dt>Exception</dt>
    00078  *  <dd>Der Defaultfall, der unerwartete Fehler auffängt</dd>
    00079  * </dl>
    00080  *
    00081  * @version $Revision: 1.7 $
    00082  * @author Simon Tiffert
    00083  */
    00084 public class FehlerAusgabe
    00085 {
    00086   /** Name der Eingabedatei, um diese im Fehlerfall mit auszugeben */
    00087   String eingabeDateiName;
    00088
    00089   /** BufferedWriter der Ausgabedatei */
    00090   BufferedWriter bw;
    00091
    00092   /** Exception, die genauer untersucht wird */
    00093   Exception exception;
    00094
    00095   /**
    00096    * Der Konstruktor sorgt dafür, dass der Fehler verarbeitet wird
    00097    * und das Attribut eingabeDateiName gesetzt wird.
    00098    *
    00099    * @param bw BufferedWriter der Ausgabedatei
    00100    * @param exception Exception, die genauer untersucht wird
    00101    * @param dateiName Name der Eingabedatei
    00102    */
    00103   public FehlerAusgabe(
    00104     BufferedWriter bw,
    00105     Exception exception,
    00106     String dateiName)
    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   }
    00120
    00121   /**
    00122    * Diese Funktion dient der Auswertung von Fehlern, die im
    00123    * Programmablauf passieren können. Dabei wird eine Unterteilung in
    00124    * Fehlerklassen vorgenommen.
    00125    *
    00126    */
    00127   private void printError()
    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   }
    00226
    00227   /**
    00228    * Diese Funktion schreibt den gefundenen Fehler in die Ausgabedatei
    00229    * und fängt einen eventuellen Fehler ab. Zudem ist hier noch eine
    00230    * Debugausgabe implementiert, die den Fehler zusätzlich noch auf dem
    00231    * Bildschirm ausgibt
    00232    *
    00233    * @param s Der Text der in die Ausgabedatei geschrieben wird
    00234    */
    00235   private void schreibeFehler(String s)
    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   }
    00316
    00317   /**
    00318    * Diese Funktion erzeugt die Hilfeausgabe, die angezeigt wird, wenn
    00319    * das Programm falsch aufgerufen wurde oder wenn der Parameter -h
    00320    * eingegeben wurde.
    00321    *
    00322    */
    00323   private static void hilfeAusgabe()
    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   }
    00336 }

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