Generierte Dokumentation der praktischen Arbeit von Simon Tiffert

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

# Eingabe.java

gehe zur Dokumentation dieser Datei

    00001 /*
    00002  *
    00003  * Datei:   Eingabe.java
    00004  *
    00005  * ---------------------------------
    00006  *
    00007  * Datum:           $Date: 2004/05/13 14:03:48 $
    00008  * Autor:           Simon Tiffert
    00009  * Prüfungsnummer:  40
    00010  * Firma:           T-Systems
    00011  * eMail-Adresse:   simon.tiffert@t-systems.com
    00012  * Version:         $Revision: 1.23 $
    00013  *
    00014  * ---------------------------------
    00015  *
    00016  */
    00017 package main.eingabe;
    00018
    00019 import java.io.File;
    00020 import java.io.FileNotFoundException;
    00021 import java.io.FileReader;
    00022 import java.io.IOException;
    00023 import java.io.LineNumberReader;
    00024 import java.io.Reader;
    00025 import java.util.NoSuchElementException;
    00026 import java.util.StringTokenizer;
    00027
    00028 import main.tools.eingabe.MyLineNumberReader;
    00029 import main.verarbeitung.IsSperrfeldException;
    00030 import main.verarbeitung.IsStartpunktException;
    00031 import main.verarbeitung.Matrix;
    00032 import main.verarbeitung.WrongDimensionException;
    00033
    00034 /**
    00035  * Diese Klasse liest die Eingabedaten aus einer Datei aus und
    00036  * erstellt die Matrix, die für die spätere Verarbeitung gebraucht
    00037  * wird.
    00038  *
    00039  * @version $Revision: 1.23 $
    00040  * @author Simon Tiffert
    00041  */
    00042 public class Eingabe
    00043 {
    00044   /** Feld für Matrix */
    00045   private Matrix matrix;
    00046
    00047   /**
    00048   * Konstruktor, welcher die Matrix übernimmt, die Datei zuweist und
    00049   * mit diesen Daten die Funktion leseDaten() aufruft
    00050   *
    00051   * @param matrix Zentrale Datenstruktur mit Matrix
    00052   * @param dateiName Name der Eingabedatei
    00053   * @throws UnexpectedCharacterException Unerwartetes Zeichen
    00054   * @throws UnexpectedLineException Unerwartete Zeile
    00055   * @throws UnknownCharacterException Unbekanntes Zeichen
    00056   * @throws TooFewCharactersException Zuwenig Zeichen angegeben
    00057   * @throws TooFewSperrfelderException Zuwenig Sperrfelder angegeben
    00058   * @throws FileNotFoundException Datei wurde nicht gefunden
    00059   * @throws IOException Fehler bei der Eingabe
    00060   * @throws IsSperrfeldException Doppeldefinition von Sperrfeld
    00061   * @throws IsStartpunktException Sperrfeld auf Startfeld definiert
    00062   * @throws WrongDimensionException Falsche Dimensionsangaben
    00063   */
    00064   public Eingabe(Matrix matrix, String dateiName)
    00065     throws
    00066       UnexpectedCharacterException,
    00067       UnexpectedLineException,
    00068       UnknownCharacterException,
    00069       TooFewCharactersException,
    00070       TooFewSperrfelderException,
    00071       FileNotFoundException,
    00072       IOException,
    00073       IsSperrfeldException,
    00074       IsStartpunktException,
    00075       WrongDimensionException
    00076   {
    00077     // Weise übergebene Parameter den Variablen zu
    00078     this.matrix = matrix;
    00079     File file = new File(dateiName);
    00080
    00081     // Rufe Funktion zur Abarbeitung auf
    00082     leseDaten(new FileReader(file));
    00083   }
    00084
    00085   /**
    00086    * Diese Funktion liest die Eingabedatei aus.
    00087    * Außerdem findet hier ein Teil der Syntaxüberprüfung statt,
    00088    * welche die Eingabedaten auf Korrektheit überprüft.
    00089    *
    00090    * @param stream Reader auf Eingabedatei
    00091    * @throws UnexpectedCharacterException Unerwartetes Zeichen
    00092    * @throws UnexpectedLineException Unerwartete Zeile
    00093    * @throws UnknownCharacterException Unbekanntes Zeichen
    00094    * @throws TooFewCharactersException Zuwenig Zeichen angegeben
    00095    * @throws TooFewSperrfelderException Zuwenig Sperrfelder angegeben
    00096    * @throws FileNotFoundException Datei wurde nicht gefunden
    00097    * @throws IOException Fehler bei der Eingabe
    00098    * @throws IsSperrfeldException Doppeldefinition von Sperrfeld
    00099    * @throws IsStartpunktException Sperrfeld auf Startfeld definiert
    00100    * @throws WrongDimensionException Falsche Dimensionsangaben
    00101    */
    00102   private void leseDaten(Reader stream)
    00103     throws
    00104       UnexpectedCharacterException,
    00105       UnexpectedLineException,
    00106       UnknownCharacterException,
    00107       IOException,
    00108       TooFewCharactersException,
    00109       TooFewSperrfelderException,
    00110       IsSperrfeldException,
    00111       IsStartpunktException,
    00112       WrongDimensionException
    00113   {
    00114     // Aktuell gelesene Zeile
    00115     String zeile = "";
    00116
    00117     // Anzahl gesperrter Felder
    00118     int gesperrteFelder = 0;
    00119
    00120     // Koordinaten des aktuellen Punktes
    00121     int y = 0, x = 0;
    00122
    00123     // Lies die Datei zeilenweise und speichere dabei die
    00124     // aktuelle Zeilennummer
    00125     LineNumberReader lineNumber = new MyLineNumberReader(stream, "**");
    00126
    00127     // StringTokenizer, der einen String in Token aufteilt
    00128     StringTokenizer st;
    00129
    00130     // Lies die erste Zeile aus der Eingabedatei und verarbeite sie
    00131     if ((zeile = lineNumber.readLine()) != null)
    00132     {
    00133       st = new StringTokenizer(zeile);
    00134     }
    00135     // Wenn dies nicht klappt, ist die Datei leer und eine Exception
    00136     // wird geworfen
    00137     else
    00138     {
    00139       throw new TooFewCharactersException(
    00140         "" + lineNumber.getLineNumber());
    00141     }
    00142
    00143     // Lies die Zahlen, fange ab, wenn dabei Probleme auftauchen
    00144     try
    00145     {
    00146       // Lies die Dimensionsangaben
    00147       y = Integer.parseInt(st.nextToken());
    00148       x = Integer.parseInt(st.nextToken());
    00149     }
    00150     catch (NoSuchElementException e)
    00151     {
    00152       throw new TooFewCharactersException(
    00153         "" + lineNumber.getLineNumber());
    00154     }
    00155     catch (Exception e)
    00156     {
    00157       throw new UnknownCharacterException(
    00158         "" + lineNumber.getLineNumber());
    00159     }
    00160
    00161     // Erstelle die Matrix in der Dimension y*x
    00162     matrix.setMatrix(y, x);
    00163
    00164     // Wenn noch weitere Zeichen in der Zeile sind, werfe Fehler
    00165     if (st.hasMoreTokens())
    00166     {
    00167       throw new UnexpectedCharacterException(
    00168         "" + lineNumber.getLineNumber());
    00169     }
    00170
    00171     // Lese die zweite Zeile für den Startpunkt
    00172     // wenn keine Eingabedaten da sind, werfe Exception
    00173     if ((zeile = lineNumber.readLine()) != null)
    00174     {
    00175       st = new StringTokenizer(zeile);
    00176     }
    00177     else
    00178     {
    00179       throw new TooFewCharactersException(
    00180         "" + lineNumber.getLineNumber());
    00181     }
    00182
    00183     // Lies die Zahlen, fange ab, wenn dabei Probleme auftauchen
    00184     try
    00185     {
    00186       // Lies Koordinaten des Startpunktes
    00187       y = Integer.parseInt(st.nextToken()) - 1;
    00188       x = Integer.parseInt(st.nextToken()) - 1;
    00189     }
    00190     catch (NoSuchElementException e)
    00191     {
    00192       throw new TooFewCharactersException(
    00193         "" + lineNumber.getLineNumber());
    00194     }
    00195     catch (Exception e)
    00196     {
    00197       throw new UnknownCharacterException(
    00198         "" + lineNumber.getLineNumber());
    00199     }
    00200
    00201     // Setze den Startpunkt für die Sprungfolge
    00202     matrix.setStartpunkt(y, x);
    00203
    00204     // Wenn noch weitere Zeichen in der Zeile sind, werfe Fehler
    00205     if (st.hasMoreTokens())
    00206     {
    00207       throw new UnexpectedCharacterException(
    00208         "" + lineNumber.getLineNumber());
    00209     }
    00210
    00211     // Lies Anzahl gesperrter Felder ein (optional)
    00212     if ((zeile = lineNumber.readLine()) != null)
    00213     {
    00214       // Lies die Zahl, fange ab, wenn dabei Probleme auftauchen
    00215       try
    00216       {
    00217         gesperrteFelder = Integer.parseInt(zeile);
    00218       }
    00219       catch (Exception e)
    00220       {
    00221         throw new UnknownCharacterException(
    00222           "" + lineNumber.getLineNumber());
    00223       }
    00224
    00225       // Besetze gesperrte Felder der Matrix mit '-1'
    00226       for (int i = 0; i < gesperrteFelder; i++)
    00227       {
    00228         if ((zeile = lineNumber.readLine()) != null)
    00229         {
    00230           st = new StringTokenizer(zeile);
    00231
    00232           // Lies die Zahlen, fange ab, wenn dabei Probleme auftauchen
    00233           try
    00234           {
    00235             // Lies Koordinaten,  setze den Punkt in der Matrix
    00236             y = Integer.parseInt(st.nextToken()) - 1;
    00237             x = Integer.parseInt(st.nextToken()) - 1;
    00238           }
    00239           catch (NoSuchElementException e)
    00240           {
    00241             throw new TooFewCharactersException(
    00242               "" + lineNumber.getLineNumber());
    00243           }
    00244           catch (Exception e)
    00245           {
    00246             throw new UnknownCharacterException(
    00247               "" + lineNumber.getLineNumber());
    00248           }
    00249
    00250           // Wenn noch weitere Zeichen in der Zeile sind, werfe Fehler
    00251           if (st.hasMoreTokens())
    00252           {
    00253             throw new UnexpectedCharacterException(
    00254               "" + lineNumber.getLineNumber());
    00255           }
    00256
    00257           // Setze das ermittelte Sperrfeld
    00258           matrix.setSperrfeld(y, x);
    00259         }
    00260         else
    00261         {
    00262           throw new TooFewSperrfelderException();
    00263         }
    00264       }
    00265     }
    00266
    00267     // Wenn noch weitere Zeichen am Ende der Datei sind, werfe Fehler
    00268     if (lineNumber.readLine() != null)
    00269     {
    00270       throw new UnexpectedLineException(
    00271         "" + lineNumber.getLineNumber());
    00272     }
    00273   }
    00274 }

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