public ArchiveData take() throws ClosedChannelException, InterruptedException, ProtocolException {

		// Das ArchiveData Objekt ist in dem Byte-Array kodiert.
		byte[] dataByteArray = _streamDemultiplexer.take(_indexOfStream);

		if (dataByteArray != null) {
			// Es wurde ein Datensatz empfangen
			InputStream in = new ByteArrayInputStream(dataByteArray);

			//deserialisieren
			Deserializer deserializer = SerializingFactory.createDeserializer(in);

			StreamedArchiveData streamedArchiveData = null;
			try {

				// archiveDataKind
				final int archiveDataKindCode = deserializer.readInt();
				ArchiveDataKind archiveDataKind = ArchiveDataKind.getInstance(archiveDataKindCode);

				// dataTime, steht in der Archivantwort
				final long dataTime = deserializer.readLong();

				// archiveTime, steht in der Archivantwort
				final long archiveTime = deserializer.readLong();

				// dataIndex, steht in der Archivantwort
				final long dataIndex = deserializer.readLong();

				// DataState, steht in der Archivantwort
				final int codeArchiveDataType = deserializer.readInt();
				final DataState dataState = DataState.getInstance(codeArchiveDataType);

				// Serializer-Version, mit dem der Datensatz erzeugt werden kann, auslesen
				final int serializerVersion = deserializer.readInt();

				// Wurde der Datensatz gepackt
				final byte byteCompression = deserializer.readByte();
				final ArchiveDataCompression compression = ArchiveDataCompression.getInstance(byteCompression);

				// Größe des Datensates, der als Byte-Array verschickt wurde. Ist die Größe 0, so
				// war auf Archivseite das byte-Array <code>null</code>.
				final int sizeOfData = deserializer.readInt();

				// Datensatzobjekt, das erzeugt werden soll. Der intitale Wert ist null, somit muss der else-Zweig von
				// <code>if(sizeOfData > 0)</code> nicht betrachtet werden, da dort nur data=null ausgeführt werden würde.
				Data data = null;

				if (dataState == DataState.DATA) {
					if (sizeOfData > 0) {
						// Der Datensatz in einem Byte-Array (dieser kann gepackt sein).
						// Wenn der Datensatz gepackt war, steht der entpackte Datensatz ebenfalls in dieser Variablen.
						byte[] byteData = deserializer.readBytes(sizeOfData);

						

						if (compression == ArchiveDataCompression.ZIP) {
							ByteArrayInputStream inputStream = new ByteArrayInputStream(byteData);
							InflaterInputStream unzip = new InflaterInputStream(inputStream);
							// In diesem Stream werden die entpackten Daten gespeichert
							ByteArrayOutputStream unzippedData = new ByteArrayOutputStream();

							try {
								// Speichert die ungepackten Daten
								byte[] byteArray = new byte[1000];

								// Ergebnis, nach dem die Daten eingelesen wurden (-1 bedeutet, dass es keine
								// Daten mehr gibt, die gepackt sind)
								int readResult = unzip.read(byteArray);

								while (readResult != -1) {
									unzippedData.write(byteArray, 0 , readResult);
									readResult = unzip.read(byteArray);
								}
								unzip.close();
							} catch (IOException e) {
								e.printStackTrace();
							}

							// Der Datensatz wurde entpackt und kann deserialisiert werden. Das alte byte-Array wird an dieser
							// Stelle überschrieben, da es nicht mehr benötigt wird.
							byteData = unzippedData.toByteArray();
						} else if (compression == ArchiveDataCompression.NONE) {
							// Alles in Ordnung, es wurde nicht gepackt
						} else {
							// Der Datensatz wurde mit einer unbekannte Version gepackt
							throw new RuntimeException("Entpacken von Datensätzen nicht möglich, da die Version des Packers nicht unterstützt wird, geforderte Version " + compression.toString());
						}

						// Das Byte-Array wird nun in einen Datensatz umgewandelt. Dafür muss ein neuer Deserializer
						// erzeugt werden. Dieser benutzt die übertragene Serializer-Version.
						// Dies ist nötig, da gerade alte Archivdaten mit einer älteren Serializer-Version
						// verpackt wurden.

						InputStream newUnpackedByteArray = new ByteArrayInputStream(byteData);

						//deserialisieren, diesmal mit einer anderen Serializer-Version
						try {
							Deserializer deserializerNewVersion = SerializingFactory.createDeserializer(serializerVersion, newUnpackedByteArray);
							data = deserializerNewVersion.readData(_archiveDataSpecification.getDataDescription().getAttributeGroup());
						} catch (NoSuchVersionException e) {
							e.printStackTrace();
							throw new IllegalStateException("Ein Archivdatensatz kann nicht deserialisiert werden, da das Archiv eine für die Applikation unbekannte Version zum serialisieren benutzt hat. Serializer-Version: " + serializerVersion);
						}
					}
				}

				// Objekt erzeugen, dies ist nun ein Archivdatensatz
				streamedArchiveData = new StreamedArchiveData(dataTime, archiveTime, dataIndex, dataState, archiveDataKind, data, _archiveDataSpecification.getObject(), _archiveDataSpecification.getDataDescription());

			} catch (IOException e) {
				e.printStackTrace();  //To change body of catch statement use File | Settings | File Templates.
			}
			return streamedArchiveData;
		} else {
			// Das null-Paket wurde empfangen, somit hat das Archiv alle Datensätze versandt, die zu der Archivanfrage
			// gehörten.
			_query.countFinishedStream();
			return null;
		}
	}