Generierte Dokumentation der praktischen Arbeit von Simon Tiffert

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

# Ausgabe.java

gehe zur Dokumentation dieser Datei

    00001 /*
    00002  *
    00003  * Datei:   Ausgabe.java
    00004  *
    00005  * ---------------------------------
    00006  *
    00007  * Datum:           $Date: 2004/05/13 13:21:23 $
    00008  * Autor:           Simon Tiffert
    00009  * Prüfungsnummer:  40
    00010  * Firma:           T-Systems
    00011  * eMail-Adresse:   simon.tiffert@t-systems.com
    00012  * Version:         $Revision: 1.15 $
    00013  *
    00014  * ---------------------------------
    00015  *
    00016  */
    00017
    00018 package main.ausgabe;
    00019
    00020 import java.io.BufferedWriter;
    00021 import java.io.IOException;
    00022
    00023 import main.Main;
    00024 import main.verarbeitung.Matrix;
    00025
    00026 /**
    00027  * Die Klasse formatiert den Inhalt der Matrix für die grafische
    00028  * Ausgabe und gibt diese auf den angegebenen Ausgabestrom aus. Dabei
    00029  * wird sowohl die initiale Matrix, sowie die Matrix mit dem gesuchten
    00030  * Wert ausgegeben.
    00031  *
    00032  * @version $Revision: 1.15 $
    00033  * @author Simon Tiffert
    00034  */
    00035 public class Ausgabe
    00036 {
    00037   /** Die zentrale Datenstruktur mit der Matrix */
    00038   private Matrix matrix;
    00039
    00040   /**
    00041    * Konstruktor, der die Ausgabe erzeugt.
    00042    * Übergeben werden die Matrix und der BufferedWriter der
    00043    * Ausgabedatei. Erzeugt wird dann einmal die Eingabe in
    00044    * Matrixansicht, sowie die durch Verarbeitung gewonnene Matrix mit
    00045    * Wegdaten.
    00046    *
    00047    *
    00048    * @param matrix Zentrale Datenstruktur mit Matrix
    00049    * @param bw BufferedWriter der Ausgabedatei
    00050    * @throws IOException Ausgabedatei konnte nicht geschrieben werden
    00051    */
    00052   public Ausgabe(Matrix matrix, BufferedWriter bw) throws IOException
    00053   {
    00054     // setze das Attribut matrix
    00055     this.matrix = matrix;
    00056
    00057     // Matrix im Anfangszustand ausgeben; Zustand 'false'
    00058     this.ausgabe(bw, false);
    00059
    00060     // wenn ein Weg gefunden wurde, dann wird die Matrix im Endzustand
    00061     // ausgegeben; Zustand 'true'
    00062     if (matrix.isWegGefunden())
    00063     {
    00064       this.ausgabe(bw, true);
    00065     }
    00066     // ansonsten erfolgt die Ausgabe, dass kein Weg gefunden wurde
    00067     else
    00068     {
    00069       this.keinWegGefundenAusgabe(bw);
    00070     }
    00071   }
    00072
    00073   /**
    00074    * Funktion, die ausgibt, dass keine Sprungfolge gefunden wurde
    00075    *
    00076    * @param bw BufferedWriter der Ausgabedatei
    00077    * @throws IOException Fehler beim Schreiben auf Datei
    00078    */
    00079   private void keinWegGefundenAusgabe(BufferedWriter bw)
    00080     throws IOException
    00081   {
    00082     String s = "    Keine Sprungfolge gefunden - Aufgabe unlösbar";
    00083
    00084     // gib im Debugmodus die Information auch auf dem Bildschirm aus
    00085     if (Main.debug)
    00086     {
    00087       System.out.println(s);
    00088     }
    00089
    00090     // schreibe die Meldung in die Ausgabedatei
    00091     bw.write(System.getProperty("line.separator"));
    00092     bw.write(s);
    00093   }
    00094
    00095   /**
    00096    * Diese Funktion gibt die Matrix grafisch auf dem angegebenen
    00097    * Ausgabestrom aus.
    00098    * Dabei gibt es zwei Zustände, einmal den Anfangszustand der Matrix,
    00099    * der aus den Eingabedaten erzeugt wird, sowie den Endzustand, der
    00100    * einen gefundenen Weg ausgibt.
    00101    *
    00102    * @param bw BufferedWriter für die Ausgabedatei
    00103    * @param zustand <code>false</code>: Anfangszustand,
    00104    *                <code>true</code>:  Endzustand
    00105    * @throws IOException Fehler beim Schreiben auf Datei
    00106    */
    00107   private void ausgabe(BufferedWriter bw, boolean zustand)
    00108     throws IOException
    00109   {
    00110     // Hier wird die Ausgabe zusammengebaut
    00111     StringBuffer ausgabeString = new StringBuffer();
    00112
    00113     // Zeilenumbruch nach Betriebssystem anpassen
    00114     String lineEnd = System.getProperty("line.separator");
    00115
    00116     // Falls dies scheitert, setze Standard Zeilenumbruch
    00117     if (lineEnd == null)
    00118     {
    00119       lineEnd = "\n";
    00120     }
    00121
    00122     // Tabulator
    00123     String tabulator = "    ";
    00124
    00125     // Matrixdimensionen lesen
    00126     int y = matrix.getYDimension();
    00127     int x = matrix.getXDimension();
    00128
    00129     // Trennzeichen für formatierte Ausgabe ermitteln
    00130     String trennzeichen = "+";
    00131
    00132     for( int i=0; i<x; i++ )
    00133     {
    00134       trennzeichen+=" -- +";
    00135     }
    00136
    00137     // Gib noch einen Header nach Zustand aus
    00138     if (zustand)
    00139     {
    00140       ausgabeString.append(
    00141         lineEnd + lineEnd + tabulator + "Ausgabedatei: " + lineEnd);
    00142       ausgabeString.append(tabulator + "*************" + lineEnd);
    00143     }
    00144     else
    00145     {
    00146       ausgabeString.append(
    00147         lineEnd + tabulator + "Eingabedaten: " + lineEnd);
    00148       ausgabeString.append(tabulator + "*************" + lineEnd);
    00149     }
    00150
    00151     // Ausgabe in einer zweifach-geschachtelten for-Schleife
    00152     // y-Werte durchlaufen
    00153     for (int i = 0; i < y; i++)
    00154     {
    00155       // erste Zeile der Matrix ausgeben
    00156       ausgabeString.append(lineEnd + tabulator);
    00157       ausgabeString.append(trennzeichen);
    00158       ausgabeString.append(lineEnd + tabulator);
    00159
    00160       // x-Werte durchlaufen
    00161       for (int j = 0; j < x; j++)
    00162       {
    00163         // Zeichen an aktueller Matrixposition lesen
    00164         // und entsprechend formatieren
    00165         String zeichen = " ";
    00166         int wert = matrix.getWert(i, j);
    00167
    00168         switch (wert)
    00169         {
    00170           // Gesperrte Felder
    00171           case -1 :
    00172             zeichen = "X";
    00173             break;
    00174             // Leere Felder
    00175           case 0 :
    00176             zeichen = matrix.isStartpunkt(i,j) ? "1" : " ";
    00177             break;
    00178             // Startpunkt
    00179           case 1 :
    00180             zeichen = "1";
    00181             break;
    00182             // Nummern der Sprungfolge
    00183           default :
    00184             if (zustand)
    00185               zeichen = "" + wert;
    00186             else
    00187               zeichen = " ";
    00188         }
    00189
    00190         // Zeichen ausgeben
    00191         ausgabeString.append(
    00192           "| " + (zeichen.length() < 2 ? " " : "") + zeichen + " ");
    00193       }
    00194       ausgabeString.append("|");
    00195     }
    00196     // letzte Formatierungszeile ausgeben
    00197     ausgabeString.append(lineEnd + tabulator);
    00198     ausgabeString.append(trennzeichen);
    00199     ausgabeString.append(lineEnd);
    00200
    00201     // ist der Debugmodus gesetzt, dann gib die Fehlermeldung
    00202     // zusätzlich auf dem Bildschirm aus
    00203     if (Main.debug)
    00204     {
    00205       System.out.println(ausgabeString);
    00206     }
    00207
    00208     // schreibe in die Ausgabedatei
    00209     bw.write(ausgabeString.toString());
    00210   }
    00211 }

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