Generierte Dokumentation der praktischen Arbeit von Simon Tiffert

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

# Main.java

gehe zur Dokumentation dieser Datei

    00001 /*
    00002  *
    00003  * Datei:   Main.java
    00004  *
    00005  * ---------------------------------
    00006  *
    00007  * Datum:           $Date: 2004/05/13 09:16:13 $
    00008  * Autor:           Simon Tiffert
    00009  * Prüfungsnummer:  40
    00010  * Firma:           T-Systems
    00011  * eMail-Adresse:   simon.tiffert@t-systems.com
    00012  * Version:         $Revision: 1.16 $
    00013  *
    00014  * ---------------------------------
    00015  *
    00016  */
    00017 package main;
    00018
    00019 import java.io.BufferedWriter;
    00020 import java.io.IOException;
    00021 import main.ausgabe.Ausgabe;
    00022 import main.ausgabe.FehlerAusgabe;
    00023 import main.eingabe.Eingabe;
    00024 import main.tools.file.OutputFile;
    00025 import main.verarbeitung.Matrix;
    00026 import main.verarbeitung.Verarbeitung;
    00027
    00028 /**
    00029  * Diese Klasse steuert den Ablauf des Programms.
    00030  * Hier kann man in der main-Funktion den Ablauf des EVA Prinzips
    00031  * erkennen. Da hier auch zentral Fehler abgefangen werden, war es
    00032  * nötig, die Ausgabedatei schon sehr früh im Programmablauf zu öffnen,
    00033  * da Exceptions sonst nicht in Datei geschrieben werden könnten.
    00034  * In dieser Klasse befindet sich auch das zentrale Matrix-Element,
    00035  * welches per Referenz an die Unterteile Eingabe, Verarbeitung und
    00036  * Ausgabe übergeben wird.<br><br>
    00037  * Zudem befindet sich hier der Parser für die Eingabeparameter.
    00038  * Dieser sorgt dafür, dass wichtige Flags in dieser Klasse gesetzt
    00039  * sind.
    00040  * Abgefangen werden:
    00041  * <ul>
    00042  *  <li>
    00043  *    -d DATEINAME (erkennt den Parameter und setzt den Dateinamen)
    00044  *  </li>
    00045  *
    00046  *  <li>
    00047  *    -debug (setzt das Programm in den Debugmodus, bei dem die
    00048  *            Ausgaben auch auf dem Bildschirm ausgegeben werden).
    00049  *  </li>
    00050  *
    00051  *  <li>
    00052  *    -overwrite (überschreibt eine vorhandene Ausgabedatei. Dies
    00053  *                erleichtert das Testen, kann aber im normalen
    00054  *                Ablauf unerwünscht sein)
    00055  *  </li>
    00056  *
    00057  *  <li>
    00058  *    -h (zeigt die Hilfe an, wie das Programm aufgerufen wird. Die
    00059  *        Hilfe wird auch automatisch angezeigt, wenn Parameter falsch
    00060  *        angegeben wurden)
    00061  *  </li>
    00062  * </ul>
    00063  *
    00064  *
    00065  * @version $Revision: 1.16 $
    00066  * @author Simon Tiffert
    00067  */
    00068 public class Main
    00069 {
    00070   /** maximale Größe der Matrix */
    00071   public static final int maxDimension = 6;
    00072
    00073   /** setzt den Debug-Modus */
    00074   public static boolean debug = false;
    00075
    00076   /** setzt den Overwrite-Modus */
    00077   public static boolean overwrite = false;
    00078
    00079   /** Die zentrale Datenstruktur mit der Matrix */
    00080   public static Matrix matrix = new Matrix();
    00081
    00082   /**
    00083    * main-Funktion des Programms.
    00084    * Hier wird die Verarbeitung des Programms gesteuert und
    00085    * die Fehlerabfrage durchgeführt, die zur weiteren Verarbeitung
    00086    * weitergereicht wird.
    00087    *
    00088    * @param args Programmparameter -d DATEINAME [-h]
    00089    *        [-debug][-overwrite]
    00090    */
    00091   public static void main(String[] args)
    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   }
    00142
    00143   /**
    00144    * Diese Funktion parst die Eingabeparameter. Dabei wird überprüft,
    00145    * ob eine Eingabedatei angegeben wurde. Zudem werden weitere
    00146    * Parameter erkannt und fehlerhafte sowie doppelte Parameter werden
    00147    * erkannt und als Exception geworfen.
    00148    * <br />
    00149    * Erkannt werden:
    00150    * <ul>
    00151    *  <li>-d DATEINAME    (Pflichtparameter)</li>
    00152    *  <li>-h              (Hilfe)</li>
    00153    *  <li>-debug          (Debugmodus)</li>
    00154    *  <li>-overwrite      (Overwrite-Modus, der die Ausgabedatei
    00155    *                        überschreibt)</li>
    00156    * </ul>
    00157    *
    00158    *
    00159    * @param parameter Übergabeparameter der main-Funktion
    00160    * @return Übergebenen Dateinamen
    00161    * @throws WrongParameterException Fehlerhafte Parameter
    00162    * @throws NoInputException Fehlende Parameter
    00163    */
    00164   private static String parameterParser(String[] parameter)
    00165     throws WrongParameterException, NoInputException
    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   }
    00297
    00298 }

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