- java.lang.Object
-
- org.refcodes.io.AbstractBytesDestination
-
- All Implemented Interfaces:
ByteDestination
,BytesDestination
,org.refcodes.mixin.Loggable
- Direct Known Subclasses:
AbstractBytesReceiver
public abstract class AbstractBytesDestination extends Object implements BytesDestination, org.refcodes.mixin.Loggable
TheAbstractBytesDestination
is a base abstract implementation of theBytesDestination
interface providing common functionality for concrete real implementations. A blocking queue is used internally to which received datagrams are put viapushDatagram(byte)
and which can be retrieved viareceiveByte()
. ThepushDatagram(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 viapushDatagram(byte)
to the queue is blocked until elements are taken from the queue viareceiveByte()
. So cautions are taken to prevent a memory leak.
-
-
Field Summary
Fields Modifier and Type Field Description protected LinkedBlockingQueue<Byte>
_datagramQueue
static int
DATAGRAM_QUEUE_SIZE
-
Constructor Summary
Constructors Constructor Description AbstractBytesDestination()
Constructs aAbstractBytesDestination
with a default sized blocking queue enabling a maximum ofDATAGRAM_QUEUE_SIZE
datagrams. ------------------------------------------------------------------------- Make sure your code fetches the datagrams quick enough to prevent filling up of the queue.AbstractBytesDestination(int aCapacity)
Constructs aAbstractBytesDestination
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
All Methods Instance Methods Concrete Methods 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 aMaxLength)
Similar toBytesDestination.receiveAllBytes()
though at maximum the amount of data as of the provided length returned.-
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 Detail
-
DATAGRAM_QUEUE_SIZE
public static final int DATAGRAM_QUEUE_SIZE
- See Also:
- Constant Field Values
-
_datagramQueue
protected LinkedBlockingQueue<Byte> _datagramQueue
-
-
Constructor Detail
-
AbstractBytesDestination
public AbstractBytesDestination()
Constructs aAbstractBytesDestination
with a default sized blocking queue enabling a maximum ofDATAGRAM_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 viapushDatagram(byte)
to the queue is blocked until elements are taken from the queue viareceiveByte()
.
-
AbstractBytesDestination
public AbstractBytesDestination(int aCapacity)
Constructs aAbstractBytesDestination
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 viapushDatagram(byte)
to the queue is blocked until elements are taken from the queue viareceiveByte()
.- Parameters:
aCapacity
- The capacity of the queue holding the received datagrams.
-
-
Method Detail
-
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 interfaceByteDestination
- Specified by:
receiveByte
in interfaceBytesDestination
- Returns:
- The next byte available .
- Throws:
IOException
- Thrown in case opening or accessing an open line (connection, junction, link) caused problems.EOFException
- Signals that an end of file or end of stream has been reached unexpectedly during input.
-
receiveAllBytes
public byte[] receiveAllBytes() throws IOException
Reads (receives) the all currently available data.- Specified by:
receiveAllBytes
in interfaceBytesDestination
- Returns:
- The according data.
- Throws:
IOException
- Thrown in case opening or accessing an open line (connection, junction, link) caused problems.EOFException
- Signals that an end of file or end of stream has been reached unexpectedly during input.
-
receiveBytes
public byte[] receiveBytes(int aMaxLength) throws IOException
Similar toBytesDestination.receiveAllBytes()
though at maximum the amount of data as of the provided length returned.- Specified by:
receiveBytes
in interfaceBytesDestination
- Parameters:
aMaxLength
- 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 methodBytesDestination.receiveAllBytes()
.- Returns:
- The according data.
- Throws:
IOException
- Thrown in case opening or accessing an open line (connection, junction, link) caused problems.EOFException
- Signals that an end of file or end of stream has been reached unexpectedly during input.
-
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 viareceiveByte()
: UseAbstractBytesReceiver
extension'sAbstractBytesReceiver.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 thereceiveByte()
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 viareceiveByte()
: UseAbstractBytesReceiver
extension'sAbstractBytesReceiver.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 thereceiveByte()
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 viareceiveByte()
: UseAbstractBytesReceiver
extension'sAbstractBytesReceiver.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 thereceiveByte()
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
-
-