gdv.xport.util.AbstractFormatter Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of gdv-xport-lib Show documentation
gdv-xport-lib ist die Java-Bibliothek fuer den Umgang mit dem GDV-Format. Sie erleichtert den Export und Export dieses Datenformats.
There is a newer version: 7.2.2
Show newest version
package gdv.xport.util;

import gdv.xport.Datenpaket;
import gdv.xport.config.Config;
import gdv.xport.event.ImportListener;
import gdv.xport.satz.Datensatz;
import gdv.xport.satz.Satz;

import java.io.*;

/**
 * Dies ist das gemeinsame Oberklasse der verschiedenen Formatter. Es wird
 * z.B. von der Main-Klasse fuer die Ausgabe verwendet.
 * 
 * Seit 5.0 wird das {@link AutoCloseable}-Interface implementiert.
 * 
 *
 * @author oliver ([email protected])
 * @since 0.5.0 (29.11.2010)
 */
public abstract class AbstractFormatter implements ImportListener, AutoCloseable {

    private final Config config;
    private Writer writer;

    /**
     * Default-Konstruktor, der als Standard-Ausgabekanal stdout einstellt.
     */
    public AbstractFormatter() {
        this(System.out);
    }

    /**
     * Instantiiert einen neuen Formatter.
     *
     * @param writer the writer
     */
    public AbstractFormatter(final Writer writer) {
        this(writer, Config.getInstance());
    }

    /**
     * Legt einen neuen Formatter an.
     *
     * @param writer Writer
     * @param config Konfiguration
     */
    protected AbstractFormatter(final Writer writer, final Config config) {
        this.writer = writer;
        this.config = config;
    }

    /**
     * Instantiiert einen neuen Formatter.
     *
     * @param ostream the ostream
     */
    public AbstractFormatter(final OutputStream ostream) {
        this(new OutputStreamWriter(ostream, Config.DEFAULT_ENCODING));
    }

    /**
     * Liefert die Konfiguratipn zurueck.
     *
     * @return Konfiguration
     */
    protected final Config getConfig() {
        return config;
    }

    /**
     * Liefert den eingestellten Writer.
     *
     * @return the writer
     */
    public final Writer getWriter() {
        return writer;
    }

    /**
     * Setzt den Ausgabekanal auf den uebergebenen Writer.
     *
     * @param writer Ausgabekanal
     */
    public void setWriter(final Writer writer) {
        this.writer = writer;
    }

    /**
     * Setzt den Ausgabekanal auf den uebergebenen OutputStream.
     *
     * @param ostream OutputStream als Ausgabekanal
     */
    public void setWriter(final OutputStream ostream) {
        OutputStreamWriter ostreamWriter = new OutputStreamWriter(ostream, Config.DEFAULT_ENCODING);
        this.setWriter(ostreamWriter);
    }

    /**
     * Sobald diese Methode aufgerufen, wird der uebergebene Satz formattiert
     * ausgegeben.
     *
     * @param satz der soeben importierte Satz
     * @see ImportListener#notice(gdv.xport.satz.Satz)
     */
    @Override
    public void notice(final Satz satz) {
        try {
            this.write(satz);
        } catch (IOException ioe) {
            throw new FormatterException("cannot format " + satz, ioe);
        }
    }

    /**
     * Wenn ein Formatter als {@link ImportListener} eingesetzt werden soll,
     * muss er diese Methode ueberschreiben.
     *
     * @param satz Satz, der ausgegeben werden soll
     * @throws IOException Signals that an I/O exception has occurred.
     * @see #write(Datenpaket)
     */
    public void write(final Satz satz) throws IOException {
        throw new UnsupportedOperationException("write of " + satz + " not yet supported by " + this.getClass());
    }

    /**
     * Ausgabe eines kompletten Datenpakets. Diese Methode war urspruenglich
     * abstrakt, ist aber jetzt nicht mehr unbedingt noetig, wenn
     * {@link #write(Satz)} ueberschrieben wurde.
     *
     * @param datenpaket Datenpaket, das formattiert ausgegeben werden soll
     * @throws IOException bei Problemen mit der Generierung
     * @see #write(Satz)
     */
    public void write(final Datenpaket datenpaket) throws IOException {
        this.write(datenpaket.getVorsatz());
        for (Datensatz satz : datenpaket.getDatensaetze()) {
            this.write(satz);
        }
        this.write(datenpaket.getNachsatz());
        this.writer.flush();
    }

    /**
     * Ausgabe des uebergebenen Strings.
     *
     * @param content the content
     * @throws IOException Signals that an I/O exception has occurred.
     */
    public void write(final String content) throws IOException {
        this.writer.write(content);
    }

    /**
     * Schliesst die Writer-Resource.
     *
     * @throws IOException falls was schief geht
     * @since 5.0
     */
    @Override
    public void close() throws IOException {
        writer.close();
    }

}