Module org.refcodes.io

Package org.refcodes.io

Class AbstractBytesDestination

java.lang.Object

org.refcodes.component.AbstractConnectable

org.refcodes.io.AbstractBytesDestination

All Implemented Interfaces:

ByteDestination, BytesDestination

Direct Known Subclasses:

AbstractBytesReceiver

public abstract class AbstractBytesDestination
extends org.refcodes.component.AbstractConnectable
implements BytesDestination

The AbstractBytesDestination is a base abstract implementation of the BytesDestination interface providing common functionality for concrete real implementations. A blocking queue is used internally to which received datagrams are put via pushDatagram(byte) and which can be retrieved via receiveByte(). The pushDatagram(byte) method is your hook when extending this class. Make sure your code fetches the datagrams quick enough to prevent filling up of the queue. In case the queue is filled up, adding elements via pushDatagram(byte) to the queue is blocked until elements are taken from the queue via receiveByte(). So cautions are taken to prevent a memory leak.

Field Summary

Fields

Modifier and Type	Field	Description
protected LinkedBlockingQueue<Byte>	_datagramQueue
static final int	DATAGRAM_QUEUE_SIZE

Constructor Summary

Constructors

Constructor	Description
AbstractBytesDestination()	Constructs a AbstractBytesDestination with a default sized blocking queue enabling a maximum of DATAGRAM_QUEUE_SIZE datagrams. ------------------------------------------------------------------------- Make sure your code fetches the datagrams quick enough to prevent filling up of the queue.
AbstractBytesDestination(int aCapacity)	Constructs a AbstractBytesDestination with a custom sized blocking queue enabling a maximum of datagrams as specified by the capacity parameter. ------------------------------------------------------------------------- Make sure your code fetches the datagrams quick enough to prevent filling up of the queue.

Method Summary

Modifier and Type	Method	Description
protected void	pushDatagram(byte aDatagram)	Pushes a datagram into the receiver and puts it into the blocking queue containing the so far received datagrams.
protected void	pushDatagrams(byte[] aDatagrams)	Pushes datagrams into the receiver and puts them into the blocking queue containing the so far received datagrams.
protected void	pushDatagrams(byte[] aDatagrams, int aOffset, int aLength)	Pushes datagrams into the receiver and puts them into the blocking queue containing the so far received datagrams.
byte[]	receiveAllBytes()	Reads (receives) the all currently available data.
byte	receiveByte()	Reads (receives) the next byte, in case none byte is available, then this method blocks until one is available.
byte[]	receiveBytes(int aLength)	Similar to BytesDestination.receiveAllBytes() though at maximum the amount of data as of the provided length returned.

Methods inherited from class org.refcodes.component.AbstractConnectable

isThrownAsOfAlreadyClosed

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Methods inherited from interface org.refcodes.io.BytesDestination

receiveBytes

Field Details

DATAGRAM_QUEUE_SIZE

public static final int DATAGRAM_QUEUE_SIZE

See Also:

• Constant Field Values

_datagramQueue

protected LinkedBlockingQueue<Byte> _datagramQueue

Constructor Details

AbstractBytesDestination

public AbstractBytesDestination()

Constructs a AbstractBytesDestination with a default sized blocking queue enabling a maximum of DATAGRAM_QUEUE_SIZE datagrams. ------------------------------------------------------------------------- Make sure your code fetches the datagrams quick enough to prevent filling up of the queue. In case the queue is filled up, adding elements via pushDatagram(byte) to the queue is blocked until elements are taken from the queue via receiveByte().

AbstractBytesDestination

public AbstractBytesDestination(int aCapacity)

Constructs a AbstractBytesDestination with a custom sized blocking queue enabling a maximum of datagrams as specified by the capacity parameter. ------------------------------------------------------------------------- Make sure your code fetches the datagrams quick enough to prevent filling up of the queue. In case the queue is filled up, adding elements via pushDatagram(byte) to the queue is blocked until elements are taken from the queue via receiveByte().

Parameters:

aCapacity - The capacity of the queue holding the received datagrams.

Method Details

receiveByte

public byte receiveByte()
                 throws IOException

Reads (receives) the next byte, in case none byte is available, then this method blocks until one is available.

Specified by:

receiveByte in interface ByteDestination

Specified by:

receiveByte in interface BytesDestination

Returns:

The next byte available .

Throws:

IOException - Thrown in case opening or accessing an open line (connection, junction, link) caused problems.

receiveAllBytes

public byte[] receiveAllBytes()
                       throws IOException

Reads (receives) the all currently available data.

Specified by:

receiveAllBytes in interface BytesDestination

Returns:

The according data.

Throws:

IOException - Thrown in case opening or accessing an open line (connection, junction, link) caused problems.

receiveBytes

public byte[] receiveBytes(int aLength)
                    throws IOException

Similar to BytesDestination.receiveAllBytes() though at maximum the amount of data as of the provided length returned.

Specified by:

receiveBytes in interface BytesDestination

Parameters:

aLength - The block-size which is not to exceeded by the returned data. A value of -1 specifies to retrieve all available datagrams (same behavior as method BytesDestination.receiveAllBytes().

Returns:

The according data.

Throws:

IOException - Thrown in case opening or accessing an open line (connection, junction, link) caused problems.

pushDatagram

protected void pushDatagram(byte aDatagram)
                     throws IOException

Pushes a datagram into the receiver and puts it into the blocking queue containing the so far received datagrams. Them datagrams can be retrieved via receiveByte(): Use AbstractBytesReceiver extension's AbstractBytesReceiver.available() to test beforehand whether there is a datagram available.

Parameters:

aDatagram - The datagram to be pushed at the end of the blocking queue; to be retrieved with the receiveByte() method.

Throws:

IOException - the open exception

pushDatagrams

protected void pushDatagrams(byte[] aDatagrams)
                      throws IOException

Pushes datagrams into the receiver and puts them into the blocking queue containing the so far received datagrams. Them datagrams can be retrieved via receiveByte(): Use AbstractBytesReceiver extension's AbstractBytesReceiver.available() to test beforehand whether there is a datagram available.

Parameters:

aDatagrams - The datagrams to be pushed at the end of the blocking queue; to be retrieved with the receiveByte() method.

Throws:

IOException - the open exception

pushDatagrams

protected void pushDatagrams(byte[] aDatagrams,
 int aOffset,
 int aLength)
                      throws IOException

Pushes datagrams into the receiver and puts them into the blocking queue containing the so far received datagrams. Them datagrams can be retrieved via receiveByte(): Use AbstractBytesReceiver extension's AbstractBytesReceiver.available() to test beforehand whether there is a datagram available.

Parameters:

aDatagrams - The datagrams to be pushed at the end of the blocking queue; to be retrieved with the receiveByte() method.

aOffset - The offset to start taking data from to be pushed.

aLength - The number of elements to be pushed from the offset onwards.

Throws:

IOException - the open exception