gdv.xport.DatenpaketStreamer 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
/*
 * Copyright (c) 2009 - 2014 by Oli B. Licensed under the Apache License,
 * Version 2.0 (the "License"); you may not use this file except in compliance
 * with the License. You may obtain a copy of the License at
 * http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law
 * or agreed to in writing, software distributed under the License is
 * distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 * KIND, either express orimplied. See the License for the specific language
 * governing permissions and limitations under the License. (c)reated 23.10.2009
 * by Oli B. ([email protected])
 */
package gdv.xport;

import gdv.xport.config.Config;
import gdv.xport.event.ImportListener;
import gdv.xport.feld.Version;
import gdv.xport.io.Importer;
import gdv.xport.io.PushbackLineNumberReader;
import gdv.xport.io.RecordReader;
import gdv.xport.io.RecyclingInputStreamReader;
import gdv.xport.satz.Satz;
import gdv.xport.satz.Vorsatz;
import gdv.xport.util.SatzTyp;

import java.io.IOException;
import java.io.InputStream;
import java.io.Reader;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
 * Im Gegensatz zur {@link Datenpaket}-Klasse wird hier ein Datenpaket nicht komplett in den Speicher geladen, sondern satzweise gelesen und anschliessend
 * verworfen. Vorher werden noch die angemeldeten Listener informiert, damit diese die Daten verarbeiten (z.B. exportieren) koennen.
 *
 * @author oliver
 * @since 1.0
 */
public class DatenpaketStreamer {

    private final PushbackLineNumberReader reader;
    private final List importListener = new ArrayList<>();
    private Map satzartVersionen = new HashMap<>();

    /**
     * Legt einen neuen {@link DatenpaketStreamer} an.
     *
     * @param istream der InputStream
     */
    public DatenpaketStreamer(final InputStream istream) {
        this(new RecyclingInputStreamReader(istream, Config.DEFAULT_ENCODING));
    }

    /**
     * Legt einen neuen {@link DatenpaketStreamer} an.
     *
     * @param reader der Reader
     */
    public DatenpaketStreamer(final Reader reader) {
        this.reader = new PushbackLineNumberReader(new RecordReader(reader), 256);
    }

    /**
     * Hierueber kann sich ein Listener registrieren.
     *
     * @param listener ein Listener
     */
    public void register(final ImportListener listener) {
        this.importListener.add(listener);
    }

    /**
     * Hiermit wird ein einzelnes Datenpaket gelesen und die verschiedenen Listener ueber den jeweils importierten Satz informiert. Damit koennen die Listener
     * eine weitere Verarbeitung (wie z.B. Export) anstossen.
     *
     * @throws IOException Signals that an I/O exception has occurred.
     */
    public void readDatenpaket() throws IOException {
        readVorsatz();
        while (true) {
            Satz satz = Datenpaket.importSatz(reader, satzartVersionen);
            notice(satz);
            if (satz.getSatzart() == 9999) {
                break;
            }
        }
    }

    /**
     * 
     * Hiermit kann geprueft werden, ob die aktuelle Zeile ein Vorsatz
     * (Satzart 0001) ist und damit der Anfang eines Datenpaketes entspricht.
     * 
     * 
     * Diese Methode ist dazu gedacht, Dateien mit mehr als einem Datenpaket
     * einfach einlesen zu koennen.
     * 
     * 
     * Beispiel:
     * 
     *      * while (datenpaketStreamer.canReadDatenpaket()) {
     *     datenpaketStreamer.readDatenpaket();
     * }
     * 
     *
     * @return true, wenn aktuelle Zeile Satzart 0001 (Vorsatz) hat
     */
    public boolean canReadDatenpaket() {
        try {
            return Importer.of(reader).readSatzart() == 1;
        } catch (IOException | NumberFormatException ex) {
            return false;
        }
    }

    private void readVorsatz() throws IOException {
        Vorsatz vorsatz = new Vorsatz();
        vorsatz.importFrom(reader);
        satzartVersionen = vorsatz.getSatzartVersionen();
        notice(vorsatz);
    }

    private void notice(Satz satz) {
        for (ImportListener listener : this.importListener) {
            listener.notice(satz);
        }
    }

}