AbstractLogicalFile

/*
 *  jDTAUS Banking RI DTAUS
 *  Copyright (C) 2005 Christian Schulte
 *  <cs@schulte.it>
 *
 *  This library is free software; you can redistribute it and/or
 *  modify it under the terms of the GNU Lesser General Public
 *  License as published by the Free Software Foundation; either
 *  version 2.1 of the License, or any later version.
 *
 *  This library is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 *  Lesser General Public License for more details.
 *
 *  You should have received a copy of the GNU Lesser General Public
 *  License along with this library; if not, write to the Free Software
 *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 *
 */
package org.jdtaus.banking.dtaus.ri.zka;

import java.io.IOException;
import java.text.ParseException;
import java.util.Arrays;
import java.util.Calendar;
import java.util.Date;
import java.util.EventListener;
import java.util.Locale;
import javax.swing.event.EventListenerList;
import org.jdtaus.banking.AlphaNumericText27;
import org.jdtaus.banking.TextschluesselVerzeichnis;
import org.jdtaus.banking.dtaus.Checksum;
import org.jdtaus.banking.dtaus.CorruptedException;
import org.jdtaus.banking.dtaus.Header;
import org.jdtaus.banking.dtaus.LogicalFile;
import org.jdtaus.banking.dtaus.Transaction;
import org.jdtaus.banking.dtaus.spi.CurrencyCounter;
import org.jdtaus.banking.dtaus.spi.Fields;
import org.jdtaus.banking.dtaus.spi.HeaderValidator;
import org.jdtaus.banking.dtaus.spi.IllegalHeaderException;
import org.jdtaus.banking.dtaus.spi.IllegalTransactionException;
import org.jdtaus.banking.dtaus.spi.TransactionValidator;
import org.jdtaus.banking.messages.ChecksumErrorMessage;
import org.jdtaus.banking.messages.ChecksumsFileMessage;
import org.jdtaus.banking.messages.IllegalDataMessage;
import org.jdtaus.banking.spi.CurrencyMapper;
import org.jdtaus.core.container.ContainerFactory;
import org.jdtaus.core.container.Implementation;
import org.jdtaus.core.io.FileOperations;
import org.jdtaus.core.io.util.FlushableFileOperations;
import org.jdtaus.core.lang.spi.MemoryManager;
import org.jdtaus.core.logging.spi.Logger;
import org.jdtaus.core.messages.DeletesBlocksMessage;
import org.jdtaus.core.messages.InsertsBlocksMessage;
import org.jdtaus.core.monitor.spi.Task;
import org.jdtaus.core.monitor.spi.TaskMonitor;
import org.jdtaus.core.nio.util.Charsets;
import org.jdtaus.core.text.Message;
import org.jdtaus.core.text.spi.ApplicationLogger;

/**
 * Abstrakte Klasse für {@code LogicalFile}-Implementierungen.
 * <p>Stellt diverse Hilfs-Methoden sowie die Überprüfung von Vor- und Nachbedingungen zur Verfügung.</p>
 * <p><b>Hinweis:</b><br/>
 * Implementierung ist nicht vor gleichzeitigen Zugriffen unterschiedlicher Threads geschützt.</p>
 *
 * @author <a href="mailto:cs@schulte.it">Christian Schulte</a>
 * @version $JDTAUS: AbstractLogicalFile.java 8810 2012-12-04 00:45:37Z schulte $
 */
public abstract class AbstractLogicalFile implements LogicalFile
{

    public interface Listener extends EventListener
    {

        /**
         * Gets called whenever bytes were inserted into an instance the listener is registered with. The byte
         * previously at {@code position} will have moved to {@code position + insertedBytes}.
         *
         * @param position The position of the first inserted byte.
         * @param bytes The number of bytes which were inserted at {@code position}.
         *
         * @throws IOException if reading or writing fails.
         */
        void bytesInserted( long position, long bytes ) throws IOException;

        /**
         * Gets called whenever bytes were deleted an instance the listener is registered with. The byte previously at
         * {@code position + bytes} will have moved to {@code position}.
         *
         * @param position The position of the first deleted byte.
         * @param bytes The number of bytes which were deleted starting at {@code position} inclusive.
         *
         * @throws IOException if reading or writing fails.
         */
        void bytesDeleted( long position, long bytes ) throws IOException;

    }

    /** Konstante für ASCII-Zeichensatz. */
    protected static final int ENCODING_ASCII = 1;

    /** Konstante für EBCDI-Zeichensatz. */
    protected static final int ENCODING_EBCDI = 2;

    /** Return-Code. */
    protected static final long NO_NUMBER = Long.MIN_VALUE;

    /** Maximum allowed days between create and execution date. */
    protected static final int MAX_SCHEDULEDAYS = 15;

    /** Maximale Anzahl unterstützter Transaktionen pro logischer Datei. */
    private static final int MAX_TRANSACTIONS = 9999999;

    /** 01/01/1980 00:00:00 CET. */
    private static final long VALID_DATES_START_MILLIS = 315529200000L;

    /** 12/31/2079 23:59:59 CET. */
    private static final long VALID_DATES_END_MILLIS = 3471289199999L;

    /** Anzahl Ziffern der größten, abbildbaren Zahl des Formats. */
    private static final int FORMAT_MAX_DIGITS = 17;

    /** Anzahl Zeichen der größten, abbildbaren Zeichenkette des Formats. */
    private static final int FORMAT_MAX_CHARS = 105;

    /**
     * Index = Exponent,
     * Wert = 10er Potenz.
     */
    protected static final long[] EXP10 = new long[ FORMAT_MAX_DIGITS + 1 ];

    /**
     * Index = Ziffer,
     * Wert = ASCII-Zeichen.
     */
    private static final byte[] DIGITS_TO_ASCII =
    {
        48, 49, 50, 51, 52, 53, 54, 55, 56, 57
    };

    /**
     * Index = ASCII-Code einer Ziffer,
     * Wert = Ziffer.
     */
    private static final byte[] ASCII_TO_DIGITS = new byte[ 60 ];

    /**
     * Index = Ziffer,
     * Wert = EBCDI-Zeichen.
     */
    private static final byte[] DIGITS_TO_EBCDI =
    {
        (byte) 0xF0, (byte) 0xF1, (byte) 0xF2, (byte) 0xF3, (byte) 0xF4, (byte) 0xF5, (byte) 0xF6, (byte) 0xF7,
        (byte) 0xF8, (byte) 0xF9
    };

    /**
     * Index = EBCDI-Code einer Ziffer,
     * Wert = Ziffer.
     */
    private static final byte[] EBCDI_TO_DIGITS = new byte[ 0xFA ];

    /** Charset name for the disk format. */
    private static final String DIN66003 = "ISO646-DE";

    /** Charset name for the tape format. */
    private static final String IBM273 = "IBM273";

    /** ASCII space character. */
    private static final byte ASCII_SPACE = (byte) 32;

    /** EBCDI space character. */
    private static final byte EBCDI_SPACE = (byte) 0x40;

    /** Verwendete {@code FileOperations} Implementierung. */
    private FileOperations fileOperations;

    /** Position des A-Datensatzes. */
    private long headerPosition;

    /** Position des E-Datensatzes. */
    private long checksumPosition;

    /**
     * Index = laufende Transaktionsnummer,
     * Wert = Position an der die Transaktion beginnt relativ zur Position des A-Datensatzes.
     */
    private long[] index;

    /** Zwischengespeicherter A Datensatz. */
    private Header cachedHeader = null;

    /** Zwischengespeicherter E Datensatz. */
    private Checksum cachedChecksum = null;

    /** Calendar der Instanz. */
    private final Calendar calendar = Calendar.getInstance( Locale.GERMANY );

    /** Puffer zum Lesen und Schreiben von Daten. */
    private final byte[] buffer = new byte[ FORMAT_MAX_CHARS + 1 ];

    /** Hilfs-Puffer. */
    private final StringBuffer shortDateBuffer = new StringBuffer( 6 );

    /** Hilfs-Puffer. */
    private final StringBuffer longDateBuffer = new StringBuffer( 8 );

    /** Abbildung von ISO Währungs-Codes zur Anzahl der vorhandenen Zahlungen mit der entsprechenden Währung. */
    private CurrencyCounter counter;

    /** Implementation configuration. */
    private Configuration configuration;

    /** Mininum number of bytes to copy to start any task monitoring. */
    private Integer monitoringThreshold;

    /** {@code Listener}s of the instance. */
    private final EventListenerList listeners = new EventListenerList();

    /** Pre-allocated temporary buffer. */
    private byte[] defaultBuffer;

    /**
     * Maximal erlaubte Anzahl Erweiterungsteile in einem C-Datensatz.
     * @since 1.12
     */
    private Long maximumExtensionCount;

    /** Statische Initialisierung der konstanten Felder. */
    static
    {
        for ( int i = 0; i <= FORMAT_MAX_DIGITS; i++ )
        {
            EXP10[i] = (long) Math.floor( Math.pow( 10.00D, i ) );
        }

        Arrays.fill( ASCII_TO_DIGITS, (byte) -1 );
        Arrays.fill( EBCDI_TO_DIGITS, (byte) -1 );
        ASCII_TO_DIGITS[48] = 0;
        ASCII_TO_DIGITS[49] = 1;
        ASCII_TO_DIGITS[50] = 2;
        ASCII_TO_DIGITS[51] = 3;
        ASCII_TO_DIGITS[52] = 4;
        ASCII_TO_DIGITS[53] = 5;
        ASCII_TO_DIGITS[54] = 6;
        ASCII_TO_DIGITS[55] = 7;
        ASCII_TO_DIGITS[56] = 8;
        ASCII_TO_DIGITS[57] = 9;
        EBCDI_TO_DIGITS[0xF0] = 0;
        EBCDI_TO_DIGITS[0xF1] = 1;
        EBCDI_TO_DIGITS[0xF2] = 2;
        EBCDI_TO_DIGITS[0xF3] = 3;
        EBCDI_TO_DIGITS[0xF4] = 4;
        EBCDI_TO_DIGITS[0xF5] = 5;
        EBCDI_TO_DIGITS[0xF6] = 6;
        EBCDI_TO_DIGITS[0xF7] = 7;
        EBCDI_TO_DIGITS[0xF8] = 8;
        EBCDI_TO_DIGITS[0xF9] = 9;
    }

    /**
     * Erzeugt eine neue {@code AbstractLogicalFile} Instanz.
     *
     * @see #setHeaderPosition(long)
     * @see #setChecksumPosition(long)
     * @see #setFileOperations(org.jdtaus.core.io.FileOperations)
     * @see #checksum()
     */
    protected AbstractLogicalFile()
    {
        this.calendar.setLenient( false );
        Arrays.fill( this.buffer, (byte) -1 );
    }

    /**
     * Gets the value of property {@code configuration}.
     *
     * @return Implementation configuration.
     */
    protected Configuration getConfiguration()
    {
        if ( this.configuration == null )
        {
            this.configuration = new Configuration();
        }

        return this.configuration;
    }

    /**
     * Sets the value of property {@code configuration}.
     *
     * @param configuration Implementation configuration.
     */
    protected void setConfiguration( final Configuration configuration )
    {
        this.configuration = configuration;
    }

    /**
     * Liest den Wert der Property {@code headerPosition}.
     *
     * @return Position des A Datensatzes.
     */
    protected long getHeaderPosition()
    {
        return this.headerPosition;
    }

    /**
     * Schreibt den Wert der Property {@code headerPosition}.
     *
     * @param headerPosition Position des A Datensatzes.
     *
     * @throws IllegalArgumentException wenn {@code headerPosition} negativ ist.
     * @throws IOException wenn die aktuelle Anzahl Bytes nicht ermittelt werden kann.
     */
    protected void setHeaderPosition( final long headerPosition ) throws IOException
    {
        if ( headerPosition < 0L )
        {
            throw new IllegalArgumentException( Long.toString( headerPosition ) );
        }

        this.headerPosition = headerPosition;
    }

    /**
     * Liest den Wert der Property {@code checksumPosition}.
     *
     * @return Position des E-Datensatzes.
     */
    protected long getChecksumPosition()
    {
        return this.checksumPosition;
    }

    /**
     * Schreibt den Wert der Property {@code checksumPosition}.
     *
     * @param checksumPosition Position des E-Datensatzes.
     *
     * @throws IllegalArgumentException wenn {@code checksumPosition} negativ ist.
     * @throws IOException wenn die aktuelle Anzahl Byte nicht ermittelt werden kann.
     */
    protected void setChecksumPosition( final long checksumPosition ) throws IOException
    {
        if ( checksumPosition <= this.getHeaderPosition() )
        {
            throw new IllegalArgumentException( Long.toString( checksumPosition ) );
        }

        this.checksumPosition = checksumPosition;
    }

    /**
     * Ermittelt die zugrunde liegende {@code FileOperations} Implementierung.
     *
     * @return zugrunde liegende {@code FileOperations} Implementierung.
     */
    protected FileOperations getFileOperations()
    {
        return this.fileOperations;
    }

    /**
     * Ändert die zu Grunde liegende {@code FileOperations} Implementierung.
     *
     * @param fileOperations neue {@code FileOperations} Implementierung.
     *
     * @throws NullPointerException wenn {@code fileOperations} {@code null} ist.
     * @throws IOException wenn zwischengespeicherte Änderungen der vorherigen Instanz nicht geschrieben werden können.
     */
    protected void setFileOperations( final FileOperations fileOperations ) throws IOException
    {
        if ( fileOperations == null )
        {
            throw new NullPointerException( "fileOperations" );
        }

        if ( this.fileOperations != null && this.fileOperations instanceof FlushableFileOperations )
        {
            ( (FlushableFileOperations) this.fileOperations ).flush();
        }

        this.fileOperations = fileOperations;
        this.cachedHeader = null;
        this.cachedChecksum = null;
        this.index = null;
        Arrays.fill( this.buffer, (byte) -1 );
    }

    /**
     * Gets the value of property {@code monitoringThreshold}.
     *
     * @return The mininum number of bytes to copy to start any task monitoring.
     */
    public int getMonitoringThreshold()
    {
        if ( this.monitoringThreshold == null )
        {
            this.monitoringThreshold = this.getDefaultMonitoringThreshold();
        }

        return this.monitoringThreshold.intValue();
    }

    /**
     * Sets the value of property {@code monitoringThreshold}.
     *
     * @param value The mininum number of bytes to copy to start any task monitoring.
     */
    public void setMonitoringThreshold( final int value )
    {
        this.monitoringThreshold = new Integer( value );
    }

    /**
     * Gets the maximum allowed number of extensions.
     *
     * @return The maximum allowed number of extensions.
     *
     * @since 1.12
     */
    public long getMaximumExtensionCount()
    {
        if ( this.maximumExtensionCount == null )
        {
            this.maximumExtensionCount = this.getDefaultMaximumExtensionCount();
        }

        return this.maximumExtensionCount.longValue();
    }

    /**
     * Sets the maximum allowed number of extensions.
     *
     * @param value The new maximum allowed number of extensions or {@code null}.
     *
     * @since 1.12
     */
    public void setMaximumExtensionCount( final Long value )
    {
        this.maximumExtensionCount = value;
    }

    /**
     * Adds a {@code Listener} to the listener list.
     *
     * @param listener The listener to be added to the listener list.
     *
     * @throws NullPointerException if {@code listener} is {@code null}.
     */
    public void addListener( final Listener listener )
    {
        this.listeners.add( Listener.class, listener );
    }

    /**
     * Removes a {@code Listener} from the listener list.
     *
     * @param listener The listener to be removed from the listener list.
     *
     * @throws NullPointerException if {@code listener} is {@code null}.
     */
    public void removeFileOperationsListener( final Listener listener )
    {
        this.listeners.remove( Listener.class, listener );
    }

    /**
     * Gets all currently registered {@code Listener}s.
     *
     * @return all currently registered {@code Listener}s.
     */
    public Listener[] getListeners()
    {
        return (Listener[]) this.listeners.getListeners( Listener.class );
    }

    /**
     * Notifies all registered listeners about inserted bytes.
     *
     * @param position The position of the first inserted byte.
     * @param bytes The number of bytes which were inserted at {@code position}.
     *
     * @throws IOException if reading or writing fails.
     */
    protected void fireBytesInserted( final long position, final long bytes ) throws IOException
    {
        final Object[] list = this.listeners.getListenerList();
        for ( int i = list.length - 2; i >= 0; i -= 2 )
        {
            if ( list[i] == Listener.class )
            {
                ( (Listener) list[i + 1] ).bytesInserted( position, bytes );
            }
        }
    }

    /**
     * Notifies all registered listeners about deleted bytes.
     *
     * @param position The position of the first deleted byte.
     * @param bytes The number of bytes which were deleted starting at {@code position} inclusive.
     *
     * @throws IOException if reading or writing fails.
     */
    protected void fireBytesDeleted( final long position, final long bytes ) throws IOException
    {
        final Object[] list = this.listeners.getListenerList();
        for ( int i = list.length - 2; i >= 0; i -= 2 )
        {
            if ( list[i] == Listener.class )
            {
                ( (Listener) list[i + 1] ).bytesDeleted( position, bytes );
            }
        }
    }

    /**
     * Hilfs-Methode zum Lesen von Zahlen.
     * <p>Sollten ungültige Daten gelesen werden, so wird {@code NO_NUMBER} zurückgeliefert und eine entsprechende
     * {@code IllegalDataMessage} erzeugt.</p>
     *
     * @param field Feld-Konstante des zu lesenden Feldes.
     * @param position Position ab der Ziffern gelesen werden sollen.
     * @param len Anzahl von Ziffern, die gelesen werden sollen.
     * @param encoding zu verwendende Kodierung.
     *
     * @return gelesene Zahl oder {@code NO_NUMBER} wenn gelesene Daten nicht als Zahl interpretiert werden konnten.
     *
     * @throws CorruptedException wenn die Datei Fehler enthält und {@link ThreadLocalMessages#isErrorsEnabled()} gleich
     * {@code true} ist.
     * @throws IOException wenn nicht gelesen werden kann.
     *
     * @see #ENCODING_ASCII
     * @see #ENCODING_EBCDI
     * @see #NO_NUMBER
     * @see org.jdtaus.banking.dtaus.spi.Fields
     * @see ThreadLocalMessages#isErrorsEnabled()
     */
    protected Long readNumber( final int field, final long position, final int len, final int encoding )
        throws IOException
    {
        return this.readNumber(
            field, position, len, encoding, this.getConfiguration().isSpaceCharacterAllowed( field ) );

    }

    /**
     * Hilfs-Methode zum Lesen von Zahlen mit gegebenenfalls Konvertierung von Leerzeichen zu Nullen.
     * <p>Die Verwendung dieser Methode mit {@code allowSpaces == true} entspricht einem Verstoß gegen die
     * Spezifikation. Diese Methode existiert ausschließlich um ungültige Dateien lesen zu können und sollte nur in
     * diesen Fällen verwendet werden.</p>
     * <p>Sollten ungültige Daten gelesen werden, so wird {@code NO_NUMBER} zurückgeliefert und eine entsprechende
     * {@code IllegalDataMessage} erzeugt.</p>
     *
     * @param field Feld-Konstante des zu lesenden Feldes.
     * @param position Position aber der die Ziffern gelesen werden sollen.
     * @param len Anzahl von Ziffern, die gelesen werden sollen.
     * @param encoding Zu verwendende Kodierung.
     * @param allowSpaces {@code true} wenn vorhandene Leerzeichen durch Nullen ersetzt werden sollen; {@code false}
     * für eine strikte Einhaltung der Spezifikation.
     *
     * @return gelesene Zahl oder {@code NO_NUMBER} wenn gelesene Daten nicht als Zahl interpretiert werden konnten.
     *
     * @throws CorruptedException wenn die Datei Fehler enthält und {@link ThreadLocalMessages#isErrorsEnabled()} gleich
     * {@code true} ist.
     * @throws IOException wenn nicht gelesen werden kann.
     *
     * @see #ENCODING_ASCII
     * @see #ENCODING_EBCDI
     * @see #NO_NUMBER
     * @see org.jdtaus.banking.dtaus.spi.Fields
     * @see org.jdtaus.banking.dtaus.ri.zka.ThreadLocalMessages
     */
    protected Long readNumber( final int field, final long position, final int len, final int encoding,
                               final boolean allowSpaces ) throws IOException
    {
        long ret = 0L;
        final byte space;
        final byte[] table;
        final byte[] revTable;
        final String cset;
        String logViolation = null; // Wenn != null wird der Verstoß geloggt.

        if ( encoding == ENCODING_ASCII )
        {
            table = DIGITS_TO_ASCII;
            revTable = ASCII_TO_DIGITS;
            space = ASCII_SPACE;
            cset = DIN66003;
        }
        else if ( encoding == ENCODING_EBCDI )
        {
            table = DIGITS_TO_EBCDI;
            revTable = EBCDI_TO_DIGITS;
            space = EBCDI_SPACE;
            cset = IBM273;
        }
        else
        {
            throw new IllegalArgumentException( Integer.toString( encoding ) );
        }

        this.fileOperations.setFilePointer( position );
        this.fileOperations.read( this.buffer, 0, len );

        for ( int read = 0; read < len; read++ )
        {
            if ( allowSpaces && this.buffer[read] == space )
            {
                if ( logViolation == null )
                {
                    logViolation = Charsets.decode( this.buffer, 0, len, cset );
                }

                this.buffer[read] = table[0];
            }

            if ( !( this.buffer[read] >= table[0] && this.buffer[read] <= table[9] ) )
            {
                if ( ThreadLocalMessages.isErrorsEnabled() )
                {
                    throw new CorruptedException( this.getImplementation(), position );
                }
                else
                {
                    final Message msg = new IllegalDataMessage(
                        field, IllegalDataMessage.TYPE_NUMERIC, position,
                        Charsets.decode( this.buffer, 0, len, cset ) );

                    ThreadLocalMessages.getMessages().addMessage( msg );
                }

                ret = NO_NUMBER;
                logViolation = null;
                break;
            }
            else
            {
                ret += revTable[this.buffer[read] & 0xFF] * EXP10[len - read - 1];
            }
        }

        if ( logViolation != null )
        {
            if ( this.getLogger().isInfoEnabled() )
            {
                this.getLogger().info( this.getReadNumberIllegalFileInfoMessage(
                    this.getLocale(), logViolation, new Long( ret ) ) );

            }
        }

        return new Long( ret );
    }

    /**
     * Hilfs-Methode zum Schreiben von Zahlen.
     *
     * @param field Feld-Konstante des zu beschreibenden Feldes.
     * @param position Position ab der die Daten geschrieben werden sollen.
     * @param len Anzahl an Ziffern die geschrieben werden sollen. Hierbei wird linksseitig mit Nullen aufgefüllt, so
     * dass exakt {@code len} Ziffern geschrieben werden.
     * @param number Die zu schreibende Zahl.
     * @param encoding Zu verwendende Kodierung.
     *
     * @throws IllegalArgumentException wenn {@code number} nicht mit {@code len} Ziffern darstellbar ist.
     * @throws IOException wenn nicht geschrieben werden kann.
     *
     * @see #ENCODING_ASCII
     * @see #ENCODING_EBCDI
     * @see org.jdtaus.banking.dtaus.spi.Fields
     */
    protected void writeNumber( final int field, final long position, final int len, long number, final int encoding )
        throws IOException
    {
        int i;
        int pos;
        final long maxValue = EXP10[len] - 1L;
        int digit;
        final byte[] table;

        if ( number < 0L || number > maxValue )
        {
            throw new IllegalArgumentException( Long.toString( number ) );
        }

        if ( encoding == ENCODING_ASCII )
        {
            table = DIGITS_TO_ASCII;
        }
        else if ( encoding == ENCODING_EBCDI )
        {
            table = DIGITS_TO_EBCDI;
        }
        else
        {
            throw new IllegalArgumentException( Integer.toString( encoding ) );
        }

        for ( i = len - 1, pos = 0; i >= 0; i--, pos++ )
        {
            digit = (int) Math.floor( number / EXP10[i] );
            number -= ( digit * EXP10[i] );
            this.buffer[pos] = table[digit];
        }

        this.fileOperations.setFilePointer( position );
        this.fileOperations.write( this.buffer, 0, len );
    }

    /**
     * Hilds-Methode zum Lesen einer alpha-numerischen Zeichenkette.
     * <p>Sollten ungültige Daten gelesen werden, so wird {@code null} zurückgeliefert und eine entsprechende
     * {@code IllegalDataMessage} erzeugt.</p>
     *
     * @param field Feld-Konstante des zu lesenden Feldes.
     * @param position Position ab der die Zeichen gelesen werden sollen.
     * @param len Anzahl von Zeichen, die gelesen werden sollen.
     * @param encoding Zu verwendende Kodierung.
     *
     * @return gelesene Zeichenkette oder {@code null} wenn ungültige Zeichen gelesen werden.
     *
     * @throws CorruptedException wenn die Datei Fehler enthält und {@link ThreadLocalMessages#isErrorsEnabled()} gleich
     * {@code true} ist.
     * @throws IOException wenn nicht gelesen werden kann.
     *
     * @see #ENCODING_ASCII
     * @see #ENCODING_EBCDI
     * @see org.jdtaus.banking.dtaus.spi.Fields
     * @see org.jdtaus.banking.dtaus.ri.zka.ThreadLocalMessages
     */
    protected AlphaNumericText27 readAlphaNumeric( final int field, final long position, final int len,
                                                   final int encoding ) throws IOException
    {
        final String cset;
        final String str;
        AlphaNumericText27 txt = null;

        if ( encoding == ENCODING_ASCII )
        {
            cset = DIN66003;
        }
        else if ( encoding == ENCODING_EBCDI )
        {
            cset = IBM273;
        }
        else
        {
            throw new IllegalArgumentException( Integer.toString( encoding ) );
        }

        this.fileOperations.setFilePointer( position );
        this.fileOperations.read( this.buffer, 0, len );
        str = Charsets.decode( this.buffer, 0, len, cset );

        try
        {
            txt = AlphaNumericText27.parse( str );
        }
        catch ( ParseException e )
        {
            if ( this.getLogger().isDebugEnabled() )
            {
                this.getLogger().debug( e.toString() );
            }

            txt = null;
            if ( ThreadLocalMessages.isErrorsEnabled() )
            {
                throw new CorruptedException( this.getImplementation(), position );
            }
            else
            {
                final Message msg =
                    new IllegalDataMessage( field, IllegalDataMessage.TYPE_ALPHA_NUMERIC, position, str );

                ThreadLocalMessages.getMessages().addMessage( msg );
            }
        }

        return txt;
    }

    /**
     * Hilfs-Methode zum Schreiben einer Zeichenkette.
     *
     * @param field Feld-Konstante des zu beschreibenden Feldes.
     * @param position Position ab der die Zeichen geschrieben werden sollen.
     * @param len Anzahl von Zeichen die maximal geschrieben werden sollen. Sollte {@code str} kürzer als {@code len}
     * sein, wird linksseitig mit Leerzeichen aufgefüllt.
     * @param str Die zu schreibende Zeichenkette.
     * @param encoding Zu verwendende Kodierung.
     *
     * @throws NullPointerException wenn {@code str null} ist.
     * @throws IllegalArgumentException wenn {@code str} länger als {@code len} Zeichen lang ist oder ungültige Zeichen
     * enthält.
     * @throws IOException wenn nicht geschrieben werden kann.
     *
     * @see #ENCODING_ASCII
     * @see #ENCODING_EBCDI
     * @see org.jdtaus.banking.dtaus.spi.Fields
     */
    protected void writeAlphaNumeric( final int field, final long position, final int len, final String str,
                                      final int encoding ) throws IOException
    {
        final int length;
        final int delta;
        final char[] c;
        final byte[] buf;
        final byte space;
        final String cset;

        if ( str == null )
        {
            throw new NullPointerException( "str" );
        }
        if ( ( length = str.length() ) > len )
        {
            throw new IllegalArgumentException( str );
        }

        if ( encoding == ENCODING_ASCII )
        {
            space = ASCII_SPACE;
            cset = DIN66003;
        }
        else if ( encoding == ENCODING_EBCDI )
        {
            space = EBCDI_SPACE;
            cset = IBM273;
        }
        else
        {
            throw new IllegalArgumentException( Integer.toString( encoding ) );
        }

        c = str.toCharArray();
        for ( int i = c.length - 1; i >= 0; i-- )
        {
            if ( !AlphaNumericText27.checkAlphaNumeric( c[i] ) )
            {
                throw new IllegalArgumentException( Character.toString( c[i] ) );
            }
        }

        buf = Charsets.encode( str, cset );
        if ( length < len )
        {
            delta = len - length;
            System.arraycopy( buf, 0, this.buffer, 0, buf.length );
            Arrays.fill( this.buffer, buf.length, buf.length + delta, space );
        }
        else
        {
            System.arraycopy( buf, 0, this.buffer, 0, buf.length );
        }

        this.fileOperations.setFilePointer( position );
        this.fileOperations.write( this.buffer, 0, len );
    }

    /**
     * Hilfs-Methode zum Lesen einer Datums-Angabe mit zweistelliger Jahres-Zahl.
     * <p>Zweistellige Jahres-Angaben kleiner oder gleich 79 werden als {@code 2000 + zweistelliges Jahr} interpretiert.
     * Zweistellige Jahres-Angaben größer oder gleich 80 werden als {@code 1900 + zweistelliges Jahr} interpretiert.</p>
     * <p>Sollten ungültige Daten gelesen werden, so wird {@code null} zurückgeliefert und eine entsprechende
     * {@code IllegalDataMessage} erzeugt.</p>
     *
     * @param field Feld-Konstante des zu lesenden Feldes.
     * @param position Position ab der die Zeichen gelesen werden sollen.
     * @param encoding Zu verwendende Kodierung.
     *
     * @return das gelesene Datum oder {@code null} wenn kein Datum gelesen werden kann.
     *
     * @throws CorruptedException wenn die Datei Fehler enthält und {@link ThreadLocalMessages#isErrorsEnabled()} gleich
     * {@code true} ist.
     * @throws IOException wenn nicht gelesen werden kann.
     *
     * @see #ENCODING_ASCII
     * @see #ENCODING_EBCDI
     * @see org.jdtaus.banking.dtaus.spi.Fields
     * @see org.jdtaus.banking.dtaus.ri.zka.ThreadLocalMessages
     */
    protected Date readShortDate( final int field, final long position, final int encoding ) throws IOException
    {
        final int len;
        final String cset;

        Date ret = null;
        String str = null;
        boolean legal = false;
        Message msg;

        if ( encoding == ENCODING_ASCII )
        {
            cset = DIN66003;
        }
        else if ( encoding == ENCODING_EBCDI )
        {
            cset = IBM273;
        }
        else
        {
            throw new IllegalArgumentException( Integer.toString( encoding ) );
        }

        try
        {
            this.fileOperations.setFilePointer( position );
            this.fileOperations.read( this.buffer, 0, 6 );
            str = Charsets.decode( this.buffer, 0, 6, cset );
            len = str.trim().length();

            if ( len == 6 )
            {
                this.calendar.clear();
                // Tag
                this.calendar.set( Calendar.DAY_OF_MONTH, Integer.valueOf( str.substring( 0, 2 ) ).intValue() );

                // Monat
                this.calendar.set( Calendar.MONTH, Integer.valueOf( str.substring( 2, 4 ) ).intValue() - 1 );

                // Jahr
                int year = Integer.valueOf( str.substring( 4, 6 ) ).intValue();
                year = year <= 79 ? 2000 + year : 1900 + year;

                this.calendar.set( Calendar.YEAR, year );
                ret = this.calendar.getTime();

                if ( !this.checkDate( ret ) )
                {
                    if ( ThreadLocalMessages.isErrorsEnabled() )
                    {
                        throw new CorruptedException( this.getImplementation(), position );
                    }
                    else
                    {
                        msg = new IllegalDataMessage( field, IllegalDataMessage.TYPE_SHORTDATE, position, str );
                        ThreadLocalMessages.getMessages().addMessage( msg );
                    }

                    ret = null;
                }
            }

            if ( len == 0 || len == 6 )
            {
                legal = true;
            }

        }
        catch ( NumberFormatException e )
        {
            if ( this.getLogger().isDebugEnabled() )
            {
                this.getLogger().debug( e.toString() );
            }

            ret = null;
            legal = false;
        }

        if ( !legal )
        {
            if ( ThreadLocalMessages.isErrorsEnabled() )
            {
                throw new CorruptedException( this.getImplementation(), position );
            }
            else
            {
                msg = new IllegalDataMessage( field, IllegalDataMessage.TYPE_SHORTDATE, position, str );
                ThreadLocalMessages.getMessages().addMessage( msg );
            }
        }

        return ret;
    }

    /**
     * Hilfs-Methode zum Schreiben einer Datums-Angabe mit zweistelliger Jahres-Zahl.
     * <p>Es werden nur Daten mit Jahren größer oder gleich 1980 und kleiner oder gleich 2079 akzeptiert.</p>
     *
     * @param field Feld-Konstante des zu beschreibenden Feldes.
     * @param position Position ab der die Zeichen geschrieben werden sollen.
     * @param date Die zu schreibende Datums-Angabe oder {@code null} um eine optionale Datums-Angabe zu entfernen.
     * @param encoding Zu verwendende Kodierung.
     *
     * @throws IllegalArgumentException wenn das Jahr von {@code date} nicht größer oder gleich 1980 und kleiner oder
     * gleich 2079 ist.
     * @throws IOException wenn nicht geschrieben werden kann.
     *
     * @see #ENCODING_ASCII
     * @see #ENCODING_EBCDI
      * @see org.jdtaus.banking.dtaus.spi.Fields
      */
     protected void writeShortDate( final int field, final long position, final Date date, final int encoding )
         throws IOException
     {
         int i;
         final byte[] buf;
         final String cset;

         if ( encoding == ENCODING_ASCII )
         {
             cset = DIN66003;
         }
         else if ( encoding == ENCODING_EBCDI )
         {
             cset = IBM273;
         }
         else
         {
             throw new IllegalArgumentException( Integer.toString( encoding ) );
         }

         if ( date != null )
         {
             if ( !this.checkDate( date ) )
             {
                 throw new IllegalArgumentException( date.toString() );
             }

             this.shortDateBuffer.setLength( 0 );
             this.calendar.clear();
             this.calendar.setTime( date );
             // Tag
             i = this.calendar.get( Calendar.DAY_OF_MONTH );
             if ( i < 10 )
             {
                 this.shortDateBuffer.append( '0' );
             }
             this.shortDateBuffer.append( i );
             // Monat
             i = this.calendar.get( Calendar.MONTH ) + 1;
             if ( i < 10 )
             {
                 this.shortDateBuffer.append( '0' );
             }
             this.shortDateBuffer.append( i );
             // Jahr
             i = this.calendar.get( Calendar.YEAR );
             this.shortDateBuffer.append( i >= 2000 && i <= 2009 ? "0" : "" );
             this.shortDateBuffer.append( i >= 1980 && i < 2000 ? i - 1900 : i - 2000 );

             buf = Charsets.encode( this.shortDateBuffer.toString(), cset );
         }
         else
         {
             buf = Charsets.encode( "      ", cset );
         }

         this.fileOperations.setFilePointer( position );
         this.fileOperations.write( buf, 0, 6 );
     }

     /**
      * Hilfs-Methode zum Lesen einer Datums-Angabe mit vierstelliger Jahres-Zahl.
      * <p>Sollten ungültige Daten gelesen werden, so wird {@code null} zurückgeliefert und eine entsprechende
      * {@code IllegalDataMessage} erzeugt.</p>
      *
      * @param field Feld-Konstante des zu lesenden Feldes.
      * @param position Position ab der die Zeichen gelesen werden sollen.
      * @param encoding Zu verwendende Kodierung.
      *
      * @return gelesenes Datum oder {@code null} wenn nicht gelesen werden kann.
      *
      * @throws IOException wenn nicht gelesen werden kann.
      *
      * @see #ENCODING_ASCII
      * @see #ENCODING_EBCDI
      * @see org.jdtaus.banking.dtaus.spi.Fields
      * @see org.jdtaus.banking.dtaus.ri.zka.ThreadLocalMessages
      */
     protected Date readLongDate( final int field, final long position, final int encoding ) throws IOException
     {
         final int len;
         final String cset;

         boolean legal = false;
         Date ret = null;
         String str = null;
         Message msg;

         if ( encoding == ENCODING_ASCII )
         {
             cset = DIN66003;
         }
         else if ( encoding == ENCODING_EBCDI )
         {
             cset = IBM273;
         }
         else
         {
             throw new IllegalArgumentException( Integer.toString( encoding ) );
         }

         try
         {
             this.fileOperations.setFilePointer( position );
             this.fileOperations.read( this.buffer, 0, 8 );
             str = Charsets.decode( this.buffer, 0, 8, cset );
             len = str.trim().length();
             if ( len == 8 )
             {
                 this.calendar.clear();
                 // Tag
                 this.calendar.set( Calendar.DAY_OF_MONTH, Integer.valueOf( str.substring( 0, 2 ) ).intValue() );

                 // Monat
                 this.calendar.set( Calendar.MONTH, Integer.valueOf( str.substring( 2, 4 ) ).intValue() - 1 );

                 // Jahr
                 this.calendar.set( Calendar.YEAR, Integer.valueOf( str.substring( 4, 8 ) ).intValue() );

                 ret = this.calendar.getTime();
                 if ( !this.checkDate( ret ) )
                 {
                     if ( ThreadLocalMessages.isErrorsEnabled() )
                     {
                         throw new CorruptedException( this.getImplementation(), position );
                     }
                     else
                     {
                         msg = new IllegalDataMessage( field, IllegalDataMessage.TYPE_LONGDATE, position, str );
                         ThreadLocalMessages.getMessages().addMessage( msg );
                     }

                     ret = null;
                 }

             }

             if ( len == 0 || len == 8 )
             {
                 legal = true;
             }

         }
         catch ( NumberFormatException e )
         {
             if ( this.getLogger().isDebugEnabled() )
             {
                 this.getLogger().debug( e.toString() );
             }

             legal = false;
             ret = null;
         }

         if ( !legal )
         {
             if ( ThreadLocalMessages.isErrorsEnabled() )
             {
                 throw new CorruptedException( this.getImplementation(), position );
             }
             else
             {
                 msg = new IllegalDataMessage( field, IllegalDataMessage.TYPE_LONGDATE, position, str );
                 ThreadLocalMessages.getMessages().addMessage( msg );
             }
         }

         return ret;
     }

     /**
      * Hilfs-Methode zum Schreiben einer Datums-Angabe mit vierstelliger Jahres-Zahl.
      *
      * @param field Feld-Konstante des zu beschreibenden Feldes.
      * @param position Position ab der die Zeichen geschrieben werden sollen.
      * @param date Die zu schreibende Datums-Angabe oder {@code null} um eine optionale Datums-Angabe zu entfernen.
      * @param encoding Zu verwendende Kodierung.
      *
      * @throws IllegalArgumentException wenn das Jahr von {@code date} nicht größer oder gleich 1980 und kleiner oder
      * gleich 2079 ist.
      * @throws IOException wenn nicht geschrieben werden kann.
      *
      * @see #ENCODING_ASCII
      * @see #ENCODING_EBCDI
      * @see org.jdtaus.banking.dtaus.spi.Fields
      * @see org.jdtaus.banking.dtaus.ri.zka.ThreadLocalMessages
      */
     protected void writeLongDate( final int field, final long position, final Date date, final int encoding )
         throws IOException
     {
         int i;
         final byte[] buf;
         final String cset;

         if ( encoding == ENCODING_ASCII )
         {
             cset = DIN66003;
         }
         else if ( encoding == ENCODING_EBCDI )
         {
             cset = IBM273;
         }
         else
         {
             throw new IllegalArgumentException( Integer.toString( encoding ) );
         }

         if ( date != null )
         {
             if ( !this.checkDate( date ) )
             {
                 throw new IllegalArgumentException( date.toString() );
             }

             this.longDateBuffer.setLength( 0 );
             this.calendar.clear();
             this.calendar.setTime( date );
             // Tag
             i = this.calendar.get( Calendar.DAY_OF_MONTH );
             if ( i < 10 )
             {
                 this.longDateBuffer.append( '0' );
             }
             this.longDateBuffer.append( i );
             // Monat
             i = this.calendar.get( Calendar.MONTH ) + 1;
             if ( i < 10 )
             {
                 this.longDateBuffer.append( '0' );
             }
             this.longDateBuffer.append( i );
             // Jahr
             i = this.calendar.get( Calendar.YEAR );
             this.longDateBuffer.append( i );
             buf = Charsets.encode( this.longDateBuffer.toString(), cset );
         }
         else
         {
             buf = Charsets.encode( "        ", cset );
         }

         this.fileOperations.setFilePointer( position );
         this.fileOperations.write( buf, 0, 8 );
     }

     /**
      * Hilfs-Methode zum Lesen von gepackten EBCDI Zahlen.
      * <p>Sollten ungültige Daten gelesen werden, so wird {@code NO_NUMBER} zurückgeliefert und eine entsprechende
      * {@code IllegalDataMessage} erzeugt.</p>
      *
      * @param field Feld-Konstante des zu lesenden Feldes.
      * @param position Position ab der die Daten gelesen werden sollen.
      * @param len Anzahl von Byte, die gelesen werden sollen.
      * @param sign {@code true} wenn ein Vorzeichen erwartet wird; {@code false} wenn kein Vorzeichen erwartet wird.
      *
      * @return gelesene Zahl oder {@code NO_NUMBER} wenn gelesene Daten nicht als Zahl interpretiert werden konnten.
      *
      * @throws CorruptedException wenn die Datei Fehler enthält und {@link ThreadLocalMessages#isErrorsEnabled()} gleich
      * {@code true} ist.
      * @throws IOException wenn nicht gelesen werden kann.
      *
      * @see org.jdtaus.banking.dtaus.spi.Fields
      * @see ThreadLocalMessages#isErrorsEnabled()
      * @see #NO_NUMBER
      */
     protected long readNumberPackedPositive( final int field, final long position, final int len, final boolean sign )
         throws IOException
     {
         long ret = 0L;
         final int nibbles = 2 * len;
         int exp = nibbles - ( sign ? 2 : 1 );
         boolean highNibble = true;
         int read = 0;
         Message msg;

         this.fileOperations.setFilePointer( position );
         this.fileOperations.read( this.buffer, 0, len );

         for ( int nibble = 0; nibble < nibbles; nibble++, exp-- )
         {
             final int digit = highNibble ? ( ( this.buffer[read] & 0xF0 ) >> 4 ) : ( this.buffer[read++] & 0xF );

             highNibble = !highNibble;

             // Vorzeichen des letzten Nibbles.
             if ( sign && exp < 0 )
             {
                 if ( digit != 0xC )
                 {
                     if ( ThreadLocalMessages.isErrorsEnabled() )
                     {
                         throw new CorruptedException( this.getImplementation(), position );
                     }
                     else
                     {
                         msg = new IllegalDataMessage(
                             field, IllegalDataMessage.TYPE_PACKET_POSITIVE, position, Integer.toString( digit ) );

                         ThreadLocalMessages.getMessages().addMessage( msg );
                     }

                     ret = NO_NUMBER;
                     break;
                 }
             }
             else
             {
                 if ( digit < 0 || digit > 9 )
                 {
                     if ( !ThreadLocalMessages.isErrorsEnabled() )
                     {
                         throw new CorruptedException( this.getImplementation(), position );
                     }
                     else
                     {
                         msg = new IllegalDataMessage(
                             field, IllegalDataMessage.TYPE_PACKET_POSITIVE, position, Integer.toString( digit ) );

                         ThreadLocalMessages.getMessages().addMessage( msg );
                     }

                     ret = NO_NUMBER;
                     break;
                 }

                 ret += ( digit * EXP10[exp] );
             }
         }

         return ret;
     }

     /**
      * Hilfs-Methode zum Schreiben von gepackten EBCDI-Zahlen.
      *
      * @param field Feld-Konstante des zu beschreibenden Feldes.
      * @param position Position ab der die Daten geschrieben werden sollen.
      * @param len Anzahl an Byte die geschrieben werden sollen. Hierbei wird linksseitig mit Nullen aufgefüllt, so dass
      * exakt {@code len} Ziffern geschrieben werden.
      * @param number Die zu schreibende Zahl.
      * @param sign {@code true} wenn ein Vorzeichen geschrieben werden soll; {@code false} wenn kein Vorzeichen
      * geschrieben werden soll.
      *
      * @throws IllegalArgumentException wenn {@code number} nicht mit {@code len} Byte darstellbar ist.
      * @throws IOException wenn nicht geschrieben werden kann.
      *
      * @see org.jdtaus.banking.dtaus.spi.Fields
      */
     protected void writeNumberPackedPositive( final int field, final long position, final int len, long number,
                                               final boolean sign ) throws IOException
     {
         int i;
         int pos = 0;
         final int nibbles = len * 2;
         final int digits = nibbles - ( sign ? 1 : 0 );
         int exp = digits - 1;
         final long maxValue = EXP10[digits] - 1L;
         byte b = 0;
         boolean highNibble = true;

         if ( number < 0L || number > maxValue )
         {
             throw new IllegalArgumentException( Long.toString( number ) );
         }

         for ( i = 0; i < nibbles; i++, exp-- )
         {
             final int digit;

             if ( sign && exp < 0 )
             {
                 digit = 0xC;
             }
             else
             {
                 digit = (int) Math.floor( number / EXP10[exp] );
                 number -= ( digit * EXP10[exp] );
             }
             if ( highNibble )
             {
                 b = (byte) ( ( digit << 4 ) & 0xF0 );
             }
             else
             {
                 this.buffer[pos++] = (byte) ( b | digit );
             }

             highNibble = !highNibble;
         }

         this.fileOperations.setFilePointer( position );
         this.fileOperations.write( this.buffer, 0, len );
     }

     /**
      * Hilfs-Methode zum Lesen von binär gespeicherten Zahlen.
      *
      * @param field Feld-Konstante des zu lesenden Feldes.
      * @param position Position ab der die Daten gelesen werden sollen.
      * @param len Anzahl von Byte, die gelesen werden sollen.
      *
      * @return gelesene Zahl.
      *
      * @throws IllegalArgumentException wenn {@code len} negativ, {@code 0} oder größer als {@code 8} ist.
      * @throws IOException wenn nicht gelesen werden kann.
      *
      * @see org.jdtaus.banking.dtaus.spi.Fields
      */
     protected long readNumberBinary( final int field, final long position, final int len ) throws IOException
     {
         if ( len <= 0 || len > 8 )
         {
             throw new IllegalArgumentException( Integer.toString( len ) );
         }

         long ret = 0L;
         int shift = ( len - 1 ) * 8;

         this.fileOperations.setFilePointer( position );
         this.fileOperations.read( this.buffer, 0, len );

         for ( int i = 0; i < len; i++, shift -= 8 )
         {
             ret |= ( ( this.buffer[i] & 0xFF ) << shift );
         }

         return ret;
     }

     /**
      * Hilfs-Methode zum Schreiben von binär gespeicherten Zahlen.
      *
      * @param field Feld-Konstante des zu beschreibenden Feldes.
      * @param position Position ab der die Daten geschrieben werden sollen.
      * @param len Anzahl an Byte die geschrieben werden sollen.
      * @param number Die zu schreibende Zahl.
      *
      * @throws IllegalArgumentException wenn {@code len} negativ, {@code 0} oder größer als {@code 8} ist.
      * @throws IOException wenn nicht geschrieben werden kann.
      *
      * @see org.jdtaus.banking.dtaus.spi.Fields
      */
     protected void writeNumberBinary( final int field, final long position, final int len, final long number )
         throws IOException
     {
         if ( len <= 0 || len > 8 )
         {
             throw new IllegalArgumentException( Integer.toString( len ) );
         }

         int shift = ( len - 1 ) * 8;
         int i;

         for ( i = 0; i < len; i++, shift -= 8 )
         {
             this.buffer[i] = (byte) ( ( number >> shift ) & 0xFFL );
         }

         this.fileOperations.setFilePointer( position );
         this.fileOperations.write( this.buffer, 0, len );
     }

     /**
      * Prüfung einer laufenden Transaktionsnummer.
      *
      * @param id zu prüfende Transaktionsnummer.
      * @param checksum aktuelle Prüfsumme.
      *
      * @throws NullPointerException {@code if(checksum == null)}
      */
     protected boolean checkTransactionId( final int id, final Checksum checksum )
     {
         if ( checksum == null )
         {
             throw new NullPointerException( "checksum" );
         }

         final int count = checksum.getTransactionCount();
         return count > 0 && id >= 0 && id < count;
     }

     /**
      * Prüfung einer Menge von Transaktionen.
      *
      * @param transactionCount zu prüfende Menge Transaktionen.
      */
     protected boolean checkTransactionCount( final int transactionCount )
     {
         return transactionCount >= 0 && transactionCount <= MAX_TRANSACTIONS;
     }

     /**
      * Prüfung eines Datums.
      *
      * @param date zu prüfendes Datum.
      *
      * @return {@code true} wenn {@code date} im gültigen Bereich liegt; {@code false} wenn nicht,
      */
     protected boolean checkDate( final Date date )
     {
         boolean valid = false;

         if ( date != null )
         {
             final long millis = date.getTime();
             valid = millis >= VALID_DATES_START_MILLIS && millis <= VALID_DATES_END_MILLIS;
         }

         return valid;
     }

     /**
      * Hilfsmethode zum dynamischen Vergrössern des Index.
      *
      * @param index laufende Transaktionsnummer, für die der Index angepasst werden soll.
      * @param checksum aktuelle Prüfsumme zur Initialisierung des Index.
      */
     protected void resizeIndex( final int index, final Checksum checksum )
     {
         if ( this.index == null )
         {
             this.index = this.getMemoryManager().allocateLongs( checksum.getTransactionCount() + 1 );
             Arrays.fill( this.index, -1L );
         }

         while ( this.index.length < index + 1 )
         {
             int newLength = this.index.length * 2;
             if ( newLength <= index )
             {
                 newLength = index + 1;
             }
             else if ( newLength > MAX_TRANSACTIONS )
             {
                 newLength = MAX_TRANSACTIONS;
             }

             final long[] newIndex = this.getMemoryManager().allocateLongs( newLength );
             System.arraycopy( this.index, 0, newIndex, 0, this.index.length );
             Arrays.fill( newIndex, this.index.length, newIndex.length, -1L );
             this.index = newIndex;
         }
     }

     /**
      * Inserts a given number of bytes at a given position.
      *
      * @param position The position to insert bytes at.
      * @param bytes The number of bytes to insert.
      *
      * @throws IOException if inserting bytes fails.
      */
     protected void insertBytes( final long position, final long bytes ) throws IOException
     {
         final Task task = new Task();
         long toMoveByte = this.getFileOperations().getLength() - position;
         long progress = 0L;
         long progressDivisor = 1L;
         long maxProgress = toMoveByte;

         if ( toMoveByte <= 0L )
         {
             this.getFileOperations().setLength( this.getFileOperations().getLength() + bytes );
             this.fireBytesInserted( position, bytes );
             return;
         }

         final byte[] buf = this.getBuffer( toMoveByte > Integer.MAX_VALUE ? Integer.MAX_VALUE : (int) toMoveByte );
         while ( maxProgress > Integer.MAX_VALUE )
         {
             maxProgress /= 2L;
             progressDivisor *= 2L;
         }

         task.setIndeterminate( false );
         task.setCancelable( false );
         task.setMinimum( 0 );
         task.setMaximum( (int) maxProgress );
         task.setProgress( (int) progress );
         task.setDescription( new InsertsBlocksMessage() );

         final boolean monitoring = toMoveByte > this.getMonitoringThreshold();
         if ( monitoring )
         {
             this.getTaskMonitor().monitor( task );
         }

         try
         {
             long readPos = this.getFileOperations().getLength();
             while ( toMoveByte > 0L )
             {
                 final int moveLen = buf.length >= toMoveByte ? (int) toMoveByte : buf.length;
                 readPos -= moveLen;
                 final long writePos = readPos + bytes;

                 this.getFileOperations().setFilePointer( readPos );
                 int read = 0;
                 int total = 0;

                 do
                 {
                     read = this.getFileOperations().read( buf, total, moveLen - total );
                     assert read != FileOperations.EOF : "Unexpected end of file.";
                     total += read;
                 }
                 while ( total < moveLen );

                 this.getFileOperations().setFilePointer( writePos );
                 this.getFileOperations().write( buf, 0, moveLen );

                 toMoveByte -= moveLen;
                 progress += moveLen;
                 task.setProgress( (int) ( progress / progressDivisor ) );
             }
         }
         finally
         {
             if ( monitoring )
             {
                 this.getTaskMonitor().finish( task );
             }
         }

         this.fireBytesInserted( position, bytes );
     }

     /**
      * Removes a given number of bytes at a given position.
      *
      * @param position The position to remove bytes at.
      * @param bytes The number of bytes to remove.
      *
      * @throws IOException if removing bytes fails.
      */
     protected void removeBytes( final long position, final long bytes ) throws IOException
     {
         final Task task = new Task();
         long toMoveByte = this.getFileOperations().getLength() - position - bytes;
         long progress = 0L;
         long progressDivisor = 1L;
         long maxProgress = toMoveByte;

         // No blocks are following the ones to remove.
         if ( toMoveByte == 0L )
         {
             this.getFileOperations().setLength( this.getFileOperations().getLength() - bytes );
             this.fireBytesDeleted( position, bytes );
             return;
         }

         final byte[] buf = this.getBuffer( toMoveByte > Integer.MAX_VALUE ? Integer.MAX_VALUE : (int) toMoveByte );
         while ( maxProgress > Integer.MAX_VALUE )
         {
             maxProgress /= 2L;
             progressDivisor *= 2L;
         }

         task.setIndeterminate( false );
         task.setCancelable( false );
         task.setMinimum( 0 );
         task.setMaximum( (int) maxProgress );
         task.setProgress( (int) progress );
         task.setDescription( new DeletesBlocksMessage() );

         final boolean monitoring = toMoveByte > this.getMonitoringThreshold();
         if ( monitoring )
         {
             this.getTaskMonitor().monitor( task );
         }

         try
         {
             long readPos = position + bytes;
             while ( toMoveByte > 0L )
             {
                 final int len = toMoveByte <= buf.length ? (int) toMoveByte : buf.length;
                 final long writePos = readPos - bytes;

                 this.getFileOperations().setFilePointer( readPos );

                 int read = 0;
                 int total = 0;
                 do
                 {
                     read = this.getFileOperations().read( buf, total, len - total );
                     assert read != FileOperations.EOF : "Unexpected end of file.";
                     total += read;

                 }
                 while ( total < len );

                 // Move the block count blocks to the beginning.
                 this.getFileOperations().setFilePointer( writePos );
                 this.getFileOperations().write( buf, 0, len );

                 toMoveByte -= len;
                 readPos += len;
                 progress += len;
                 task.setProgress( (int) ( progress / progressDivisor ) );
             }

             this.getFileOperations().setLength( this.getFileOperations().getLength() - bytes );
         }
         finally
         {
             if ( monitoring )
             {
                 this.getTaskMonitor().finish( task );
             }
         }

         this.fireBytesDeleted( position, bytes );
     }

     private byte[] getBuffer( final int requested ) throws IOException
     {
         final long length = this.getFileOperations().getLength();

         if ( requested <= 0 || requested > length )
         {
             throw new IllegalArgumentException( Integer.toString( requested ) );
         }

         if ( this.defaultBuffer == null )
         {
             this.defaultBuffer = this.getMemoryManager().allocateBytes( this.getDefaultBufferSize() );
         }

         return requested <= this.defaultBuffer.length || this.getMemoryManager().getAvailableBytes() < requested
                ? this.defaultBuffer : this.getMemoryManager().allocateBytes( requested );

     }

     /**
      * Ermittelt die Größe eines Satzabschnitts.
      *
      * @return Größe eines Satzabschnitts in Byte.
      */
     protected abstract int getBlockSize();

     /**
      * Ermittelt den Typ eines Satzabschnitts.
      *
      * @param position Position des zu lesenden Satzabschnitts.
      *
      * @return Datensatztyp des an {@code position} beginnenden Satzabschnitts {@code position}.
      *
      * @throws IOException wenn nicht gelesen werden kann.
      */
     protected abstract char getBlockType( long position ) throws IOException;

     /**
      * Ermittlung der Bytes einer Transaktion.
      *
      * @param transaction Transaktion, für die die Anzahl benötigter Bytes ermittelt werden soll.
      *s
      * @return Anzahl der von {@code transaction} belegten Bytes.
      */
     protected abstract int byteCount( Transaction transaction );

     /**
      * Gets implementation meta-data.
      *
      * @return implementation meta-data.
      */
     protected abstract Implementation getImplementation();

     /**
      * Liest den A Datensatz. Die entsprechenden Vor- und Nachbedingungen werden in
      * {@link AbstractLogicalFile#getHeader()} geprüft.
      *
      * @return A Datensatz.
      *
      * @throws IOException wenn nicht gelesen werden kann.
      *
      * @see #getHeaderPosition()
      */
     protected abstract Header readHeader() throws IOException;

     /**
      * Schreibt den A Datensatz. Die entsprechenden Vor- und Nachbedingungen werden in
      * {@link AbstractLogicalFile#setHeader(Header)} geprüft.
      *
      * @param header A Datensatz.
      *
      * @throws IOException wenn nicht geschrieben werden kann.
      *
      * @see #getHeaderPosition()
      */
     protected abstract void writeHeader( Header header ) throws IOException;

     /**
      * Liest den E Datensatz. Die entsprechenden Vor- und Nachbedingungen werden in
      * {@link AbstractLogicalFile#getChecksum()} geprüft.
      *
      * @return E Datensatz.
      *
      * @throws IOException wenn nicht gelesen werden kann.
      *
      * @see #getChecksumPosition()
      */
     protected abstract Checksum readChecksum() throws IOException;

     /**
      * Schreibt den E Datensatz. Die entsprechenden Vor- und Nachbedingungen werden in
      * {@link AbstractLogicalFile#setChecksum(Checksum)} geprüft.
      *
      * @param checksum E Datensatz.
      *
      * @throws IOException wenn nicht geschrieben werden kann.
      *
      * @see #getChecksumPosition()
      */
     protected abstract void writeChecksum( Checksum checksum ) throws IOException;

     /**
      * Liest einen C Datensatz. Die entsprechenden Vor- und Nachbedingungen werden in
      * {@link AbstractLogicalFile#getTransaction(int)} geprüft.
      *
      * @param position Position des C Datensatzes.
      * @param transaction Instanz, die die gelesenen Daten aufnehmen soll.
      *
      * @return an {@code position} beginnender C Datensatz.
      *
      * @throws IOException wenn nicht gelesen werden kann.
      */
     protected abstract Transaction readTransaction( long position, Transaction transaction ) throws IOException;

     /**
      * Schreibt einen C Datensatz. Die entsprechenden Vor- und Nachbedingungen werden in
      * {@link AbstractLogicalFile#setTransaction(int, Transaction)} geprüft.
      *
      * @param position Position des C Datensatzes.
      * @param transaction Daten des C Datensatzes.
      *
      * @throws IOException wenn nicht geschrieben werden kann.
      */
     protected abstract void writeTransaction( long position, Transaction transaction ) throws IOException;

     public Header getHeader() throws IOException
     {
         if ( this.cachedHeader == null )
         {
             this.cachedHeader = this.readHeader();
         }

         return (Header) this.cachedHeader.clone();
     }

     public Header setHeader( final Header header ) throws IOException
     {
         IllegalHeaderException result = null;
         final Header old = this.getHeader();
         final HeaderValidator[] validators = this.getHeaderValidator();

         for ( int i = validators.length - 1; i >= 0; i-- )
         {
             result = validators[i].assertValidHeader( this, header, this.counter, result );
         }

         if ( result != null && result.getMessages().length > 0 )
         {
             throw result;
         }

         this.writeHeader( header );
         this.cachedHeader = (Header) header.clone();
         return old;
     }

     public Checksum getChecksum() throws IOException
     {
         if ( this.cachedChecksum == null )
         {
             this.cachedChecksum = this.readChecksum();
         }

         return (Checksum) this.cachedChecksum.clone();
     }

     protected void setChecksum( final Checksum checksum ) throws IOException
     {
         this.writeChecksum( checksum );
         this.cachedChecksum = (Checksum) checksum.clone();
     }

     protected void checksum() throws IOException
     {
         final Checksum c = new Checksum();
         Transaction t = new Transaction();
         final Task task = new Task();
         task.setIndeterminate( true );
         task.setCancelable( false );
         task.setDescription( new ChecksumsFileMessage() );

         try
         {
             this.getTaskMonitor().monitor( task );

             final long fileLength = this.fileOperations.getLength();
             long position = this.getHeaderPosition();
             char type = this.getBlockType( position );
             this.setChecksumPosition( position + this.getBlockSize() );
             this.counter = new CurrencyCounter();

             if ( type == 'A' )
             {
                 this.getHeader(); // A-Datensatz prüfen.

                 position += this.getBlockSize();
                 int transactionIndex = 0;

                 while ( position < fileLength && ( type = this.getBlockType( position ) ) == 'C' )
                 {
                     this.resizeIndex( transactionIndex, c );
                     this.index[transactionIndex] = position - this.getHeaderPosition();
                     t = this.readTransaction( this.getHeaderPosition() + this.index[transactionIndex++], t );
                     final int len = this.byteCount( t );

                     if ( t.getCurrency() != null )
                     {
                         this.counter.add( t.getCurrency() );
                     }
                     if ( t.getAmount() != null && t.getTargetAccount() != null && t.getTargetBank() != null )
                     {
                         c.add( t );
                     }

                     position += len;
                     this.setChecksumPosition( position );
                     c.setTransactionCount( transactionIndex );
                 }

                 this.setChecksumPosition( position );
                 if ( type == 'E' )
                 {
                     final Checksum stored = this.getChecksum();
                     if ( !stored.equals( c ) )
                     {
                         if ( ThreadLocalMessages.isErrorsEnabled() )
                         {
                             throw new CorruptedException( this.getImplementation(), position );
                         }
                         else
                         {
                             final Message msg = new ChecksumErrorMessage( stored, c, this.getHeaderPosition() );
                             ThreadLocalMessages.getMessages().addMessage( msg );
                         }
                     }
                 }
                 else
                 {
                     if ( ThreadLocalMessages.isErrorsEnabled() )
                     {
                         throw new CorruptedException(
                             this.getImplementation(), position + DTAUSDisk.ERECORD_OFFSETS[1] );

                     }
                     else
                     {
                         final Message msg = new IllegalDataMessage(
                             Fields.FIELD_E2, IllegalDataMessage.TYPE_CONSTANT, position + DTAUSDisk.ERECORD_OFFSETS[1],
                             Character.toString( type ) );

                         ThreadLocalMessages.getMessages().addMessage( msg );
                     }
                 }
             }
             else
             {
                 if ( ThreadLocalMessages.isErrorsEnabled() )
                 {
                     throw new CorruptedException( this.getImplementation(), position + DTAUSDisk.ARECORD_OFFSETS[1] );
                 }
                 else
                 {
                     final Message msg = new IllegalDataMessage(
                         Fields.FIELD_A2, IllegalDataMessage.TYPE_CONSTANT, position + DTAUSDisk.ARECORD_OFFSETS[1],
                         Character.toString( type ) );

                     ThreadLocalMessages.getMessages().addMessage( msg );
                 }
             }
         }
         finally
         {
             this.getTaskMonitor().finish( task );
         }
     }

     public final void createTransaction( final Transaction transaction ) throws IOException
     {
         this.addTransaction( transaction );
     }

     public int addTransaction( final Transaction transaction ) throws IOException
     {
         final Checksum checksum = this.getChecksum();
         final int newCount = checksum.getTransactionCount() + 1;

         if ( !this.checkTransactionCount( newCount ) )
         {
             throw new ArrayIndexOutOfBoundsException( newCount );
         }

         IllegalTransactionException result = null;
         final TransactionValidator[] validators = this.getTransactionValidator();

         for ( int i = validators.length - 1; i >= 0; i-- )
         {
             result = validators[i].assertValidTransaction( this, transaction, result );
         }

         if ( result != null && result.getMessages().length > 0 )
         {
             throw result;
         }

         this.counter.add( transaction.getCurrency() );
         checksum.setTransactionCount( newCount );
         checksum.add( transaction );

         final int transactionIndex = checksum.getTransactionCount() - 1;
         final int len = this.byteCount( transaction );
         this.insertBytes( this.getChecksumPosition(), len );
         this.setChecksumPosition( this.getChecksumPosition() + len );
         this.resizeIndex( transactionIndex, checksum );
         this.index[transactionIndex] = this.getChecksumPosition() - len - this.getHeaderPosition();
         this.writeTransaction( this.getHeaderPosition() + this.index[transactionIndex], transaction );
         this.writeChecksum( checksum );
         this.cachedChecksum = checksum;
         return transactionIndex;
     }

     public Transaction getTransaction( final int index ) throws IOException
     {
         final Checksum checksum = this.getChecksum();
         if ( !this.checkTransactionId( index, checksum ) )
         {
             throw new ArrayIndexOutOfBoundsException( index );
         }

         return this.readTransaction( this.index[index] + this.getHeaderPosition(), new Transaction() );
     }

     public Transaction setTransaction( final int index, final Transaction transaction ) throws IOException
     {
         final Checksum checksum = this.getChecksum();
         if ( !this.checkTransactionId( index, checksum ) )
         {
             throw new ArrayIndexOutOfBoundsException( index );
         }

         IllegalTransactionException result = null;
         final TransactionValidator[] validators = this.getTransactionValidator();

         for ( int i = validators.length - 1; i >= 0; i-- )
         {
             result = validators[i].assertValidTransaction( this, transaction, result );
         }

         if ( result != null && result.getMessages().length > 0 )
         {
             throw result;
         }

         final Transaction old = this.getTransaction( index );

         if ( !old.getCurrency().getCurrencyCode().equals( transaction.getCurrency().getCurrencyCode() ) )
         {
             this.counter.substract( old.getCurrency() );
             this.counter.add( transaction.getCurrency() );
         }

         int i;
         checksum.subtract( old );
         checksum.add( transaction );
         final int oldLen = this.byteCount( old );
         final int newLen = this.byteCount( transaction );
         if ( oldLen < newLen )
         {
             final int delta = newLen - oldLen;
             this.insertBytes( this.getHeaderPosition() + this.index[index], delta );

             for ( i = index + 1; i < this.index.length; i++ )
             {
                 if ( this.index[i] != -1L )
                 {
                     this.index[i] += delta;
                 }
             }

             this.setChecksumPosition( this.getChecksumPosition() + delta );
         }
         else if ( oldLen > newLen )
         {
             final int delta = oldLen - newLen;
             this.removeBytes( this.getHeaderPosition() + this.index[index], delta );

             for ( i = index + 1; i < this.index.length; i++ )
             {
                 if ( this.index[i] != -1L )
                 {
                     this.index[i] -= delta;
                 }
             }

             this.setChecksumPosition( this.getChecksumPosition() - delta );
         }

         this.writeTransaction( this.getHeaderPosition() + this.index[index], transaction );
         this.writeChecksum( checksum );
         this.cachedChecksum = checksum;
         return old;
     }

     public Transaction removeTransaction( final int index ) throws IOException
     {
         final Checksum checksum = this.getChecksum();
         if ( !this.checkTransactionId( index, checksum ) )
         {
             throw new ArrayIndexOutOfBoundsException( index );
         }

         final Transaction removed = this.getTransaction( index );
         checksum.setTransactionCount( checksum.getTransactionCount() - 1 );
         checksum.subtract( removed );
         this.counter.substract( removed.getCurrency() );

         final int len = this.byteCount( removed );
         this.removeBytes( this.getHeaderPosition() + this.index[index], len );
         this.setChecksumPosition( this.getChecksumPosition() - len );
         for ( int i = index + 1; i < this.index.length; i++ )
         {
             if ( this.index[i] != -1L )
             {
                 this.index[i] -= len;
             }

             this.index[i - 1] = this.index[i];
         }

         this.writeChecksum( checksum );
         this.cachedChecksum = checksum;
         return removed;
     }

     //--Dependencies------------------------------------------------------------

 // <editor-fold defaultstate="collapsed" desc=" Generated Code ">//GEN-BEGIN:jdtausDependencies
     // This section is managed by jdtaus-container-mojo.

     /**
      * Gets the configured <code>Logger</code> implementation.
      *
      * @return The configured <code>Logger</code> implementation.
      */
     protected Logger getLogger()
     {
         return (Logger) ContainerFactory.getContainer().
             getDependency( this, "Logger" );

     }

     /**
      * Gets the configured <code>MemoryManager</code> implementation.
      *
      * @return The configured <code>MemoryManager</code> implementation.
      */
     protected MemoryManager getMemoryManager()
     {
         return (MemoryManager) ContainerFactory.getContainer().
             getDependency( this, "MemoryManager" );

     }

     /**
      * Gets the configured <code>ApplicationLogger</code> implementation.
      *
      * @return The configured <code>ApplicationLogger</code> implementation.
      */
     protected ApplicationLogger getApplicationLogger()
     {
         return (ApplicationLogger) ContainerFactory.getContainer().
             getDependency( this, "ApplicationLogger" );

     }

     /**
      * Gets the configured <code>TaskMonitor</code> implementation.
      *
      * @return The configured <code>TaskMonitor</code> implementation.
      */
     protected TaskMonitor getTaskMonitor()
     {
         return (TaskMonitor) ContainerFactory.getContainer().
             getDependency( this, "TaskMonitor" );

     }

     /**
      * Gets the configured <code>TextschluesselVerzeichnis</code> implementation.
      *
      * @return The configured <code>TextschluesselVerzeichnis</code> implementation.
      */
     protected TextschluesselVerzeichnis getTextschluesselVerzeichnis()
     {
         return (TextschluesselVerzeichnis) ContainerFactory.getContainer().
             getDependency( this, "TextschluesselVerzeichnis" );

     }

     /**
      * Gets the configured <code>CurrencyMapper</code> implementation.
      *
      * @return The configured <code>CurrencyMapper</code> implementation.
      */
     protected CurrencyMapper getCurrencyMapper()
     {
         return (CurrencyMapper) ContainerFactory.getContainer().
             getDependency( this, "CurrencyMapper" );

     }

     /**
      * Gets the configured <code>HeaderValidator</code> implementation.
      *
      * @return The configured <code>HeaderValidator</code> implementation.
      */
     protected HeaderValidator[] getHeaderValidator()
     {
         return (HeaderValidator[]) ContainerFactory.getContainer().
             getDependency( this, "HeaderValidator" );

     }

     /**
      * Gets the configured <code>TransactionValidator</code> implementation.
      *
      * @return The configured <code>TransactionValidator</code> implementation.
      */
     protected TransactionValidator[] getTransactionValidator()
     {
         return (TransactionValidator[]) ContainerFactory.getContainer().
             getDependency( this, "TransactionValidator" );

     }

     /**
      * Gets the configured <code>Locale</code> implementation.
      *
      * @return The configured <code>Locale</code> implementation.
      */
     protected Locale getLocale()
     {
         return (Locale) ContainerFactory.getContainer().
             getDependency( this, "Locale" );

     }

 // </editor-fold>//GEN-END:jdtausDependencies

     //------------------------------------------------------------Dependencies--
     //--Properties--------------------------------------------------------------

 // <editor-fold defaultstate="collapsed" desc=" Generated Code ">//GEN-BEGIN:jdtausProperties
     // This section is managed by jdtaus-container-mojo.

     /**
      * Gets the value of property <code>defaultMonitoringThreshold</code>.
      *
      * @return Number of bytes which need to minimally be copied to enable any task monitoring during copy operations.
      */
     protected java.lang.Integer getDefaultMonitoringThreshold()
     {
         return (java.lang.Integer) ContainerFactory.getContainer().
             getProperty( this, "defaultMonitoringThreshold" );

     }

     /**
      * Gets the value of property <code>defaultMaximumExtensionCount</code>.
      *
      * @return Default maximum number of extensions allowed in a C record (field C18).
      */
     protected java.lang.Long getDefaultMaximumExtensionCount()
     {
         return (java.lang.Long) ContainerFactory.getContainer().
             getProperty( this, "defaultMaximumExtensionCount" );

     }

     /**
      * Gets the value of property <code>defaultBufferSize</code>.
      *
      * @return Size of the pre-alocated default buffer in byte.
      */
     protected int getDefaultBufferSize()
     {
         return ( (java.lang.Integer) ContainerFactory.getContainer().
             getProperty( this, "defaultBufferSize" ) ).intValue();

     }

 // </editor-fold>//GEN-END:jdtausProperties

     //--------------------------------------------------------------Properties--
     //--Messages----------------------------------------------------------------

 // <editor-fold defaultstate="collapsed" desc=" Generated Code ">//GEN-BEGIN:jdtausMessages
     // This section is managed by jdtaus-container-mojo.

     /**
      * Gets the text of message <code>readNumberIllegalFileInfo</code>.
      * <blockquote><pre>Ein ungültiges Leerzeichen in einem numerischen Feld wurde zu einer Null konvertiert. Gelesene Zeichenkette "{0}" wurde zur Zahl "{1,number}" konvertiert.</pre></blockquote>
      * <blockquote><pre>An illegal space character in a numeric field has been converted to zero. Converted string "{0}" to number "{1,number}".</pre></blockquote>
      *
      * @param locale The locale of the message instance to return.
      * @param readString format parameter.
      * @param convertedNumber format parameter.
      *
      * @return the text of message <code>readNumberIllegalFileInfo</code>.
      */
     protected String getReadNumberIllegalFileInfoMessage( final Locale locale,
             final java.lang.String readString,
             final java.lang.Number convertedNumber )
     {
         return ContainerFactory.getContainer().
             getMessage( this, "readNumberIllegalFileInfo", locale,
                 new Object[]
                 {
                     readString,
                     convertedNumber
                 });

     }

 // </editor-fold>//GEN-END:jdtausMessages

     //----------------------------------------------------------------Messages--
 }