Stream-Murks!

[jf]

Hallo Freunde der If-Schleife!

Ich habe ein Verständnisproblem zu Streams. Ich lese in einer Schleife aus einem InputStream mittels der Methode read() jeweils immer nur ein Byte. Wenn dieses Byte den Wert -1 hat, breche ich den Schleifendurchlauf ab. Der Doku zufolge müsste das alles korrekt sein:

read

public abstract int read()
throws IOException

Reads the next byte of data from the input stream. The value byte is returned as an int in the range 0 to 255. If no byte is available because the end of the stream has been reached, the value -1 is returned. This method blocks until input data is available, the end of the stream is detected, or an exception is thrown.

A subclass must provide an implementation of this method.

Returns:
the next byte of data, or -1 if the end of the stream is reached.
Throws:
IOException - if an I/O error occurs.

Da an dieser Stelle etwas nicht stimmte, baute ich mir einen Test und musste feststellen, dass am Ende des Streams, anstatt -1 stets 0 zurückgegeben wird.
=> jetzt frage ich mich natürlich, ob hier nur die Doku falsch ist (was echt ärgerlich wäre!) - oder ob mein Stream wirklich so viele Bytes mit dem Wert 0 hat, dass er den Java Heap zum überlaufen bringt.

Da ich auf einem Embedded System arbeite, welches für den Zugriff auf Dateine spezielle Bibliotheken benötigt und das Debugging auf dem Gerät recht umständlich ist, musste ich die Erzeugung des InputStreams in meinem Test-Paket nachbauen. Dafür habe ich folgende zwei Klassen ohne Änderung verwendet:

java.io: StringReader.java
Koders Code Search: ReaderInputStream.java - Java - AL20

Der StringReader erzeugt aus einem hart-kodierten String ein Reader-Objekt, welches dann an den Konstruktor der ReaderInputStream-Klasse übergeben wird.

Da dies aber recht offizielle Klassen sind (Oracle/Apache), sollten diese eigentlich nicht die Ursache des Problems sein... ???:L

In dem ReaderInputStream ist aber ebenfalls eine read()-Methode implementiert - und zwar wie folgt:

    public synchronized int read() throws IOException {
        if (in == null) {
            throw new IOException("Stream Closed");
        }

        byte result;
        if (slack != null && begin < slack.length) {
            result = slack[begin];
            if (++begin == slack.length) {
                slack = null;
            }
        } else {
            byte[] buf = new byte[1];
            if (read(buf, 0, 1) <= 0) {             // hier wird auf <= geprüft, also -1 UND 0!
                result = -1;
            }
            result = buf[0];
        }

        if (result < -1) {
            result += 256;
        }

        return result;
    }

Diese Implementierung berücksichtigt für read() den Rückgaberwert 0, was wiederum ein Indiz dafür wäre, dass die oben genannte Doku falsch ist.

Ich weiß nicht so recht wem ich in dieser Situation trauen soll, daher wende ich mich vertrauensvoll an die Spezialisten auf diesem Gebiet: kann mir bitte jemand etwas Erleuchtung bescheren? :bahnhof:

 

[California]

In Zeile 17 setzt Du immer den Rückgabewert auf buf[0]
(Sofern nicht die "slack" Mimik greift, was man auf Deinem Codeschnipsel nirgendwo sieht...)

 

[jf]

In Zeile 17 setzt Du

ist nicht von mir

immer den Rückgabewert auf buf[0]

stimmt, so genau habe ich es mir noch gar nicht angeschaut...

(Sofern nicht die "slack" Mimik greift, was man auf Deinem Codeschnipsel nirgendwo sieht...)

Die komplette Klasse ist über den entsprechenden Link im ersten Beitrag einsehbar.
Aber um diesen Code geht es mir im Grunde gar nicht: ich habe ein InputStream-Objekt, welches mir bei Verwendung von read() am Ende des Streams 0 zurückgibt, obwohl in der Doku von -1 gesprochen wird. - Wo liegt hier nun der Fehler???

 

[HimBromBeere]

ich tippe mal auf diese Zeile:

if (++begin == slack.length) {

Hier inkrementierst du begin um 1, BEVOR du eine Zuweisung machst. Durch die Zuwesiung machst du das Inkrement also eh wieder kaputt. Du solltest wohl eher folgendes schreiben:

if (begin++ == slack.length) {

Kann an der Stelle nur Raten, da ich von Streams annähernd keine Ahnung hab...

 

[irgendjemand]

@HimBromBeere

OUCH ...

gleich 2 fehler

1) das von dir angemerkte ist NICHT von TO ... sondern aus der klasse ReaderInputStream aus den apache commons

2) "==" ist KEINE zuweisung ... sondern ein vergleich ...

daraus ergibt sich das dein post 1) übereilt 2) unüberlegt und 3) ohne das durchlesen der resourcen sowie 4) durch fehlendes wissen einfach nur überflüssig ist ...

@TO
wenn du schon auf offizielle klassen verlinkst dann tu dies auch bitte mit der richtigen url
Java Platform SE 7 ... und nicht sonst was für ne seite ...

 

[jf]

@TO
wenn du schon auf offizielle klassen verlinkst dann tu dies auch bitte mit der richtigen url
Java Platform SE 7 ... und nicht sonst was für ne seite ...

Entschuldige bitte, mir war nicht bewusst, dass die Klassen bei Java bereits enthalten sind.
Ich hatte nach einer Möglichkeit gesucht, einen String zu einem InputStream zu konvertieren - und bin beim Googlen eben auf oben genannte Links gestoßen.

Hast evtl. auch einen Tipp zur eigentlichen Frage?
Ich habe jetzt mal in die Doku von Java7 geschaut: hier scheint read() durch readByte ersetzt worden sein. Diese Methode kennt gar keinen Rückgabewert bei Streamende - es wird stehts eine Exception geworfen:

readByte

public final byte readByte()
throws IOException

See the general contract of the readByte method of DataInput.

Bytes for this operation are read from the contained input stream.

Specified by:
readByte in interface DataInput
Returns:
the next byte of this input stream as a signed 8-bit byte.
Throws:
EOFException - if this input stream has reached the end.
IOException - the stream has been closed and the contained input stream does not support reading after close, or another I/O error occurs.
See Also:
FilterInputStream.in

Wo liegt nun der Fehler genau? - Ich verwende für die Erzeugung des InputStreams offizielle Klasse, welche fehlerfrei sein sollten. Dennoch gibt mir read() am Ende des Streams stehts 0 zurück, obwohl es laut Doku -1 sein sollte. Da im Stream aber auch ganz normal das Steuer-Zeichen mit dem Wert 0 auftauchen könnte, kann ich nicht auf ret <= 0 prüfen, um die Schleife abzubrechen. Was soll ich jetzt nur machen? ;(

 

[jf]

Zur Veranschaulichung habe ich jetzt ein kleines ausführbares Beispiel zusammenkopiert: die ReaderInputStream-Klasse ist dabei nested, weshalb ihr nur eine einzige Klasse erstellen müsst, wenn ihr es ausprobieren wollt.

package input_stream;


// for test class:
import java.io.IOException;
import java.io.InputStream;
import java.io.StringReader;

// for nested class:
//import java.io.IOException;
//import java.io.InputStream;
import java.io.Reader;


public class ReadLineTest {

	static String cfg = "\r\n" +
	                    "#Debug Level\r\n" +
	                    "# 0 = aus\r" +
	                    "# 1 = error\n" +
	                    "# 2 = warning\r\n" +
	                    "# 3 = info\r\n" +
	                    "Debug_Level = 1";


	//////////////////////////////////////////////////////////////
	// main
	//////////////////////////////////////////////////////////////
	
	public static void main(String[] arg) {
	
		System.out.println("~~~ LoadConfig-Test ~~~");
		
		StringReader r = new StringReader(cfg);
		InputStream is = new ReaderInputStream(r);
		
		System.out.println("markSupported: " + is.markSupported());		
		
		try {
			String line = "";
			
			/*
			while( !line.startsWith("Debug")) {
			line = Std.readLine(is);
			System.out.println(">" + line + "<");
			}
			*/
			while(true) {
				line = readLine(is);
				if(line == null) break;
				System.out.println(">" + line + "<");
			}
		} catch (IOException e) {
			e.printStackTrace();
		}
	}

	
	//////////////////////////////////////////////////////////////
	// readLine
	//////////////////////////////////////////////////////////////

	public static String readLine(InputStream inStream) throws IOException {
		int ret = 0;
		char ch = 0;
		StringBuffer line = new StringBuffer();

		while(true) {
			ret = inStream.read();					// read next character from stream
			//--- Zum Test ------------------------
			System.out.print("|"+ret);
			try {
				Thread.sleep(10);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
			//-------------------------------------
			if(ret == -1) return null;				// quit procedure, if end of stream is reached (can also occur on a response timeout)

			// Unix, Linux, Mac OS X, AmigaOS, BSD, weitere ASCII	LF		0A		10		\n
			// Windows, DOS, OS/2, CP/M, TOS (Atari) 				CR LF	0D 0A	13 10 	\r\n
			// Mac OS bis Version 9, Apple II 						CR		0D		13		\r
			// AIX OS & OS/390 	EBCDIC 								NEL 	15		21 				
			if(ret==10 || ret==13 || ret==21) {		// cancel loop, if end of line is reached (on carriage return or line feed)
				if(ret==13) { 						// && inStream.markSupported() -> leider immer false
					inStream.mark(1);
					ret = inStream.read();
					if(ret!=10) inStream.reset();
				}
				break;
			}
			
			ch = (char)ret;							// casting byte (integer value from 0...255) to a character
			line.append(ch);						// append new character to our StringBuffer
		}

		return line.toString();
	}
}

/*
 * Copyright 2004-2005 The Apache Software Foundation.
 *
 *  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
 *
 *      [url]http://www.apache.org/licenses/LICENSE-2.0[/url]
 *
 *  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 or implied.
 *  See the License for the specific language governing permissions and
 *  limitations under the License.
 *
 */

/**
 * Adapts a <code>Reader</code> as an <code>InputStream</code>.
 * Adapted from <CODE>StringInputStream</CODE>.
 *
 */
class ReaderInputStream extends InputStream {

    /** Source Reader */
    private Reader in;

    private String encoding = System.getProperty("file.encoding");

    private byte[] slack;

    private int begin;

    /**
     * Construct a <CODE>ReaderInputStream</CODE>
     * for the specified <CODE>Reader</CODE>.
     *
     * @param reader   <CODE>Reader</CODE>.  Must not be <code>null</code>.
     */
    public ReaderInputStream(Reader reader) {
        in = reader;
    }

    /**
     * Construct a <CODE>ReaderInputStream</CODE>
     * for the specified <CODE>Reader</CODE>,
     * with the specified encoding.
     *
     * @param reader     non-null <CODE>Reader</CODE>.
     * @param encoding   non-null <CODE>String</CODE> encoding.
     */
    public ReaderInputStream(Reader reader, String encoding) {
        this(reader);
        if (encoding == null) {
            throw new IllegalArgumentException("encoding must not be null");
        } else {
            this.encoding = encoding;
        }
    }

    /**
     * Reads from the <CODE>Reader</CODE>, returning the same value.
     *
     * @return the value of the next character in the <CODE>Reader</CODE>.
     *
     * @exception IOException if the original <code>Reader</code> fails to be read
     */
    public synchronized int read() throws IOException {
        if (in == null) {
            throw new IOException("Stream Closed");
        }

        byte result;
        if (slack != null && begin < slack.length) {
            result = slack[begin];
            if (++begin == slack.length) {
                slack = null;
            }
        } else {
            byte[] buf = new byte[1];
            if (read(buf, 0, 1) <= 0) {
                result = -1;
            }
            result = buf[0];
        }

        if (result < -1) {
            result += 256;
        }

        return result;
    }

    /**
     * Reads from the <code>Reader</code> into a byte array
     *
     * @param b  the byte array to read into
     * @param off the offset in the byte array
     * @param len the length in the byte array to fill
     * @return the actual number read into the byte array, -1 at
     *         the end of the stream
     * @exception IOException if an error occurs
     */
    public synchronized int read(byte[] b, int off, int len) throws IOException {
        if (in == null) {
            throw new IOException("Stream Closed");
        }

        while (slack == null) {
            char[] buf = new char[len]; // might read too much
            int n = in.read(buf);
            if (n == -1) {
                return -1;
            }
            if (n > 0) {
                slack = new String(buf, 0, n).getBytes(encoding);
                begin = 0;
            }
        }

        if (len > slack.length - begin) {
            len = slack.length - begin;
        }

        System.arraycopy(slack, begin, b, off, len);

        if ((begin += len) >= slack.length) {
            slack = null;
        }

        return len;
    }

    /**
     * Marks the read limit of the StringReader.
     *
     * @param limit the maximum limit of bytes that can be read before the
     *              mark position becomes invalid
     */
    public synchronized void mark(final int limit) {
        try {
            in.mark(limit);
        } catch (IOException ioe) {
            throw new RuntimeException(ioe.getMessage());
        }
    }


    /**
     * @return   the current number of bytes ready for reading
     * @exception IOException if an error occurs
     */
    public synchronized int available() throws IOException {
        if (in == null) {
            throw new IOException("Stream Closed");
        }
        if (slack != null) {
            return slack.length - begin;
        }
        if (in.ready()) {
            return 1;
        } else {
            return 0;
        }
    }

    /**
     * @return false - mark is not supported
     */
    public boolean markSupported () {
        return false;   // would be imprecise
    }

    /**
     * Resets the StringReader.
     *
     * @exception IOException if the StringReader fails to be reset
     */
    public synchronized void reset() throws IOException {
        if (in == null) {
            throw new IOException("Stream Closed");
        }
        slack = null;
        in.reset();
    }

    /**
     * Closes the Stringreader.
     *
     * @exception IOException if the original StringReader fails to be closed
     */
    public synchronized void close() throws IOException {
        if (in != null) {
            in.close();
            slack = null;
            in = null;
        }
    }
}

Dazu gibt es sogar noch eine Frage: wieso liefert mir markSupported stets false - es funktioniert dann aber doch mit mark() und reset()???

 

[Marco13]

Vorneweg: Gibt es einen Grund, warum du nicht das readLine von einem BufferedReader verwendest?

 

[jf]

Vorneweg: Gibt es einen Grund, warum du nicht das readLine von einem BufferedReader verwendest?

Ja, den gibt es: wie eingangs erwähnt, läuft die Anwendung auf einem embedded System, welches eine zurechtgestutze Version von Java verwendet: Java 1.4 ME (Micro Edition). Einen BufferedReader gibt es hier nicht.

Ich habe daher angefangen die wichtigsten Dinge wie split, replace und eben auch readline nachzuprogrammieren. Ein anderer Ansatz wäre, einfach die Klassen von den größeren Java-Versionen zu verwenden. Da aber die offiziellen Klassen sicherlich hier und da noch weitere Abhängigkeiten besitzen und zudem weitere Funktionalität besitzen, welche ich gar nicht benötige, und ich mein MIDlet nicht unötig aufblähen wollte, habe ich mich für einen eigenen Ansatz entschieden.

Meine Funktion sollte ja -der Dokumentation zufolge- eigentlich auch tun.
Mein Problem ist, dass ich das Problem noch nicht verstehe... :bahnhof:

 

[Michael...]

Im Kommentar steht leider nicht drin was zurückgegeben wird wenn der Stream/String zu Ende ist.
Aber am Stringende liefert read(byte[], int, int) in Zeile 181

-1

das byte Array

buf

bleibt im Initialisierungszustand und result wird somit in Zeile 184 auf

0

und die Methode liefert

0

zurück.

[JAVA=180] byte[] buf = new byte[1];
if (read(buf, 0, 1) <= 0) {
result = -1;
}
result = buf[0];
}

if (result < -1) {
result += 256;
}

return result;
}[/code]

Warum nutzt Du überhaupt diesen ReaderInputStream? Warum baust Du Dir die Zeile nicht mit dem StringReader zusammen? Bzw. könnte man readLine, split und replace doch einfach mit den Methoden (charAt, indexOf, substring...) der String Klasse aus der ME selbst nachbauen.

 

[jf]

Im Kommentar steht leider nicht drin was zurückgegeben wird wenn der Stream/String zu Ende ist.
Aber am Stringende liefert read(byte[], int, int) in Zeile 181

-1

das byte Array

buf

bleibt im Initialisierungszustand und result wird somit in Zeile 184 auf

0

und die Methode liefert

0

zurück.

Ok, ich wollte damit eigentlich nur aufzeigen, dass read() evtl. auch 0 als Zeichen für "Streamende" zurückliefern kann. - Allerdings wären hier wohl besser folgende Zeilen der Methode read(byte[] b, int off, int len), welche von read() verwendet wird, sinnvoller gewesen:

            int n = in.read(buf);            // Zeile 117
            if (n == -1) {
                return -1;
            }

in ist ein Reader-Objekt. An dieser Stelle wird wirklich nur -1 einfach so zurückgegeben, ohne weiteres mit slack zu machen. Interessant ist, dass bei n > 0 im Anschluss gleich noch etwas gemacht wird - warum muss dies bei n = 0 nicht getan werden?

            if (n > 0) {            // Zeile 121
                slack = new String(buf, 0, n).getBytes(encoding);
                begin = 0;
            }

Warum nutzt Du überhaupt diesen ReaderInputStream? Warum baust Du Dir die Zeile nicht mit dem StringReader zusammen?

Auf dem embedded Gerät erstelle ich eine FileConnection (spezielle Siemens/Cinterion-Bibliothek), von dieser erhalte ich einen InputStream:

InputStream is = FileCon.openInputStream();

Da "on device debugging" schwierig ist und mir sowieso unter 7 die nötigen Treiber fehlen, um auf die Hardware zuzugreifen, musste ich mir in meiner IDE ein Test-Paket erstellen, in welchem ich die Erzeugung des InputStreams nachbaue (da hier die FileConnection nicht funktioniert!).
Wenn man direkt aus dem StringReader einen InputStream bekommen kann, dann gib mir bitte ein Beispiel.

Bzw. könnte man readLine, split und replace doch einfach mit den Methoden (charAt, indexOf, substring...) der String Klasse aus der ME selbst nachbauen.

Mache ich doch! - Und genau bei dem readLine(InputStream is) habe ich eben oben geschildertes Problem. Ich würde lieber direkt aus dem Stream lesen, als vorher den Stream in einen String umzuwandeln. Ich denke, dies ist performanter und ressourcenschonender. Bitte Gegenargumente nennen, falls es welche gib!

 

[irgendjemand]

also ich denke doch das du hier einen kleinen konzept fehler hast ...

du hast nur eine 1.4 ME *ziemlich alt ...* und willst dann apache commons nutzen ?
setze dich lieber damit aus ein ander wie du das was du machen willst mit der ME gelöst bekommst ...

wenn du eine SE zur verfügung hättest würde ich sagen nimm einen ByteArrayInputStream und übergib dessen konstruktor einfach String.getBytes() ... aber das gibt es unter der ME glaube ich alles gar nicht ...

 

[jf]

also ich denke doch das du hier einen kleinen konzept fehler hast ...

du hast nur eine 1.4 ME *ziemlich alt ...* und willst dann apache commons nutzen ?
setze dich lieber damit aus ein ander wie du das was du machen willst mit der ME gelöst bekommst ...

wenn du eine SE zur verfügung hättest würde ich sagen nimm einen ByteArrayInputStream und übergib dessen konstruktor einfach String.getBytes() ... aber das gibt es unter der ME glaube ich alles gar nicht ...

Nein, ich habe keinen Konzeptfehler.
Ich möchte einfach nur Funktionen in der IDE testen und debuggen wollen. Auf meinem Rechner habe ich natürlich SE-Version von Java installiert. Die Idee mit dem ByteArrayInputStream ist daher sehr gut.

Ich habe aber zwischenzeitlich schon das Problem gefunden: die read()-Methode der ReaderInputStream-Klasse ist scheinbar wirklich anders implementiert als die üblichen read()-Methoden. Wenn ich einfach den Rückgabewert des Reader-Objektes zurückgebe, dann klappt es:

    public synchronized int read() throws IOException {
    	return in.read();
    	/*
        if (in == null) {
            throw new IOException("Stream Closed");
        }

        byte result;
        if (slack != null && begin < slack.length) {
            result = slack[begin];
            if (++begin == slack.length) {
                slack = null;
            }
        } else {
            byte[] buf = new byte[1];
            if (read(buf, 0, 1) <= 0) {
                result = -1;
            }
            result = buf[0];
        }

        if (result < -1) {
            result += 256;
        }

        return result;
    	*/
    }

Was ist überhaupt der Unterschied von Readern und Streams? Wieso diese zwei Konzepte?

 

[irgendjemand]

Reader/Writer sind in aller regel nur für darstellbaren TEXT *meist ASCII / ANSI oder teilweise auch Unicode ...

sie setzen auf die RAW-streams auf welche *im idealfall* nur bytes kennen und auch nur diese verarbeiten ...

alternativ könntest du ja versuchen den ByteArrayInputStream source mäßig zu kopieren und versuchen unter deiner ME zum laufen zu bekommen *wovon ich nicht sehr überzeugt bin ... aber probieren solltest du es mal*

was ich leider immer noch nicht ganz verstanden habe : warum musst du aus deinem String ein InputStream bauen ? ... wäre es nicht einfacher dierekt mit string-methoden zu arbeiten anstatt alles auf byte-ebene zu machen ?

 

[Michael...]

Hier mal ein ReaderInputStream mit "korrekt" implementierter read() Methode, die

-1

am String/Streamende liefert:
ReaderInputStream.java in BuildANT-1.8orgapachetoolsantutilJava Source Code / Java Documentation Java Source Code and Java Documentation

 

[jf]

Reader/Writer sind in aller regel nur für darstellbaren TEXT *meist ASCII / ANSI oder teilweise auch Unicode ...
sie setzen auf die RAW-streams auf welche *im idealfall* nur bytes kennen und auch nur diese verarbeiten ...

Ok.

alternativ könntest du ja versuchen den ByteArrayInputStream source mäßig zu kopieren und versuchen unter deiner ME zum laufen zu bekommen *wovon ich nicht sehr überzeugt bin ... aber probieren solltest du es mal*

Hat funktioniert.

was ich leider immer noch nicht ganz verstanden habe : warum musst du aus deinem String ein InputStream bauen ?

Weil ich doch meine readLine(InputStream)-Methode testen will.
Auf dem Gerät würde ich den InputStream über eine FileConnection erhalten - also aus einer Datei.
Da diese FileConnection auf meinem Windows-Dateisystem nicht funktioniert, musste ich mir eben etwas anderes einfallen lassen: daher wollte ich eben meinen hart-kodierten String in einen InputStream umwandeln, um ihn anschließend meiner readLine()-Methode übergeben zu können. Nur zum Test!

... wäre es nicht einfacher dierekt mit string-methoden zu arbeiten anstatt alles auf byte-ebene zu machen ?

Die FileConnection liefert mir nun mal einen InputStream - nur das wollte ich eben nachstellen.

 

[jf]

Hier mal ein ReaderInputStream mit "korrekt" implementierter read() Methode, die

-1

am String/Streamende liefert:
ReaderInputStream.java in BuildANT-1.8orgapachetoolsantutilJava Source Code / Java Documentation Java Source Code and Java Documentation

Ich habe den Quelltext zwar nur überflogen - er ähnelt dem, welchen ich verwandte SEHR.
Ich schätze es dürfte der gleiche Code sein.

 

[Michael...]

Ich habe den Quelltext zwar nur überflogen - er ähnelt dem, welchen ich verwandte SEHR ähnlich.

Ja

Ich schätze es dürfte der gleiche Code sein.

Nein. Die entscheide Stelle ist anders. Wie vorher geschrieben wird bei Streamende ein

-1

statt

b[0]

also

0

zurückgegeben:

	byte[] buf = new byte[1];
	if (read(buf, 0, 1) <= 0) {
		return -1;
	} else {
		result = buf[0];
	}

 

[jf]

Nein. Die entscheide Stelle ist anders. Wie vorher geschrieben wird bei Streamende ein

-1

statt

b[0]

also

0

zurückgegeben:

	byte[] buf = new byte[1];
	if (read(buf, 0, 1) <= 0) {
		return -1;
	} else {
		result = buf[0];
	}

Ah, stimmt! - Da ist ja noch ein else eingebaut.
Also bin ich bei meiner Suche anfangs einfach nur auf einen fehlerhaften Code gestoßen - das erklärt einiges!
=> Ich lerne daraus, dass ich bei Quellcode aus dem Netz verstärkt auf Datum und Version achten sollte.

Vielen Dank für eure Eingaben.