private byte[] take(int indexOfStream) {

		// Es werden soviele Nutzdaten angefordert, bis <code>_bufferSizeStream</code> erreicht wird, dann wird
		// das große Paket (mit den vielen kleinen Nutzdatenpaketen als Inhalt) verschickt.

		// Hier werden alle Informationen für das große Paket gespeichert. Dies wird später in ein byte-Array umgewandelt
		ByteArrayOutputStream bigPacket = new ByteArrayOutputStream();
		// Serializer vorbereiten
		Serializer serializer = null;
		try {
			serializer = SerializingFactory.createSerializer(_serializerVersion, bigPacket);
		} catch (NoSuchVersionException e) {
			e.printStackTrace();
			_debug.error("Die geforderte Serializer-Version kann vom Serializer des StreamMultiplexer nicht benutzt werden, geforderte Version: " + _serializerVersion);
		}

		// Wie viele Bytes wurden bereits in dem großen Paket gespeichert, dies wird benötigt um zu prüfen ob das
		// Paket schon die passende Größe hat.
		int sizeOfBigPacket = 0;

		// Es werden solange Nutzdaten in das große Paket gepackt, bis dies die gewünschte Größe hat oder null-Paket
		// von der Senderapplikation versandt wurde (null bedeutet, dass keine weiteren Nutzdaten mehr zur Verfügung stehen).

		boolean bigPacketReady = false;

		// Anmerkung: Es wird mindestens ein Nutzdatenpaket verschickt (auch wenn das eine Paket die Größe des Puffers überschreitet),
		// da die größe des aktuellen Pakets erst nach dem einfügen eines Pakets geprüft wird.

		while (bigPacketReady == false) {
			// Ein Nutzdatum anfordern
			byte[] oneData = _director.take(indexOfStream);
//			_dataCount++;
			if (oneData == null) {
				// Die Senderappliaktion hat keine Nutzdaten mehr zur Verfügung, somit muß ein "null"-Paket verpackt werden.
				// Dies wird durch einen negativen Index für die Nutzdatenpaketgröße angezeigt

				try {
					int negativPaketSize = -1;
					serializer.writeInt(negativPaketSize);
				} catch (IOException e) {
					e.printStackTrace();
				}

				// Nun muß der Stream gekennzeichnet werden, dass er nicht mehr senden braucht.
				// Das null-Paket wird in dem großen Paket aber noch verschickt.

				synchronized (_streams[indexOfStream]) {

					// Somit darf der Stream keine Daten mehr senden, ABER das letzte große Paket darf er noch verschicken.
					// Das passiert auch in der <code>sendAllStreamData()</code> Methode.
					_streams[indexOfStream].setStreamFinished();
					_debug.finer("\t\t\t\t\t\t\t\t\t\tSender verschickt null-Paket. Stream: " + indexOfStream + " und beendet den Stream");
					_numberTerminatedStreams++;
				}

			} else {
				// Es wurden Nutzdaten von der Senderapplikation geschickt

				// Wie groß ist das Nutzdatum
				int sizeOfData = oneData.length;
				sizeOfBigPacket = sizeOfBigPacket + sizeOfData;

				// Als erstes wird gespeichert wie groß der Nutzdatensatz ist und dann das Array für die Nutzdaten.
				// Somit ist beim auspacken des großen Pakets immer klar, wie groß denn nun die eigentlichen
				// Nutzdatenpakete sind (die größe steht ja vor den Nutzdatenpaketen).
				try {
					serializer.writeInt(sizeOfData);
					serializer.writeBytes(oneData);
				} catch (IOException e) {
					e.printStackTrace();
				}

			}

			if ((sizeOfBigPacket > _bufferSizeStream) || (oneData == null)) {
				// Das erzeugte Paket ist nun größer als der Puffer des Streams, somit kann das Paket verschickt werden.
				// Wenn keine Nutzdaten mehr zur Verfügung stehen (take liefert null), dann ist das Paket auch bereits
				// versandt zu werden.
				bigPacketReady = true;
			}
		}

		// Das große Paket ist nun fertig, damit der Empfänger weiß wann keine Daten (int, byte[]) mehr kommen, wird eine
		// Art EOF gesetzt. dies wird durch eine -2 symbolisiert. Jedes "bigPacket"/großes Paket bekommt diesen Stempel
		// am Ende (auch das null-Paket).

		try {
			serializer.writeInt(-2);
		} catch (IOException e) {
			e.printStackTrace();
		}

		// Das bigPaket in ein Byte-Array umwandeln
		byte[] data = bigPacket.toByteArray();

		// Das große Paket "verschicken"
		return data;
	}