public abstract class AbstractByteReceiver extends org.refcodes.component.impls.AbstractConnectableAutomaton implements ByteReceiver
AbstractByteReceiver
is a base abstract implementation of the
ByteReceiver
interface providing common functionality for concrete
real live ByteDatagramReceiver
and ByteBlockReceiver
(=
ByteReceiver
) implementations.
A blocking queue is used internally to which received datagrams are put via
#pushDatagram(Serializable)
and which can be retrieved via
readDatagram()
. 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 {@link #readDatagram()}. So cautions are taken to prevent
a memory leak.org.refcodes.component.ConnectableComponent.ConnectableAutomaton
org.refcodes.component.OpenedAccessor.OpenedMutator, org.refcodes.component.OpenedAccessor.OpenedProperty
org.refcodes.component.Closable.CloseAutomaton
Modifier and Type | Field and Description |
---|---|
protected LinkedBlockingQueue<Byte> |
_datagramQueue |
static int |
DATAGRAM_QUEUE_SIZE |
Constructor and Description |
---|
AbstractByteReceiver()
Constructs a
AbstractByteReceiver 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. |
AbstractByteReceiver(int aCapacity)
Constructs a
AbstractByteReceiver 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. |
Modifier and Type | Method and Description |
---|---|
void |
close() |
boolean |
hasDatagram()
Determines whether a datagram is available from a
DatagramSender and can
be retrieved via the #readDatagram() method. |
protected void |
pushDatagram(byte aDatagram)
Pushes a datagram into the receiver and puts it into the blocking queue
containing the so far received datagrams.
|
byte |
readDatagram()
Reads (receives) the next byte passed from a
DatagramSender
counterpart. |
byte[] |
readDatagrams()
Reads (receives) the next byte block passed from a
BlockSender or DatagramSender counterpart. |
void |
releaseAll() |
getConnectionStatus, isClosable, isClosed, isOpenable, isOpened, open, setConnectionStatus
public static final int DATAGRAM_QUEUE_SIZE
protected LinkedBlockingQueue<Byte> _datagramQueue
public AbstractByteReceiver()
AbstractByteReceiver
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(Serializable)
to the queue is blocked until
elements are taken from the queue via readDatagram()
.public AbstractByteReceiver(int aCapacity)
AbstractByteReceiver
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(Serializable)
to the queue is blocked until
elements are taken from the queue via readDatagram()
.aCapacity
- The capacity of the queue holding the received
datagrams.public byte readDatagram() throws org.refcodes.component.OpenException, InterruptedException
ByteDatagramReceiver
DatagramSender
counterpart. In case none byte is available, then this method blocks
until one is available. To prevent blocking, use the
Receivable.hasDatagram()
method to test beforehand whether a byte is
available (in a multi threaded usage scenario, Receivable.hasDatagram()
is
not a reliable indicator whether this method will block or not).
When a Thread
is waiting for a byte to be read and
Thread.interrupt()
is being called, then the operation is aborted
and an InterruptedException
is thrown.readDatagram
in interface ByteDatagramReceiver
ByteDatagramSender
counterpart.org.refcodes.component.OpenException
- Thrown in case opening or accessing an open line
(connection, junction, link) caused problems.InterruptedException
- Thrown when a Thread
is waiting,
sleeping, or otherwise occupied, and the Thread
is
interrupted, either before or during the activity.public byte[] readDatagrams() throws org.refcodes.component.OpenException, InterruptedException
ByteBlockReceiver
BlockSender
or DatagramSender
counterpart. In case none
byte block is available, then this method blocks until one is
available. To prevent blocking, use the Receivable.hasDatagram()
method to
test beforehand whether a byte is available (in a multi threaded
usage scenario, #hasBlock()
is not a reliable indicator whether
this method will block or not).
When a Thread
is waiting for a byte to be read and
Thread.interrupt()
is being called, then the operation is aborted
and an InterruptedException
is thrown.readDatagrams
in interface ByteBlockReceiver
readDatagrams
in interface ByteReceiver
BlockSender
or
DatagramReceiver
counterpart.org.refcodes.component.OpenException
- Thrown in case opening or accessing an open line
(connection, junction, link) caused problems.InterruptedException
- Thrown when a Thread
is waiting,
sleeping, or otherwise occupied, and the Thread
is
interrupted, either before or during the activity.public boolean hasDatagram() throws org.refcodes.component.OpenException
Receivable
DatagramSender
and can
be retrieved via the #readDatagram()
method.hasDatagram
in interface Receivable
#readDatagram()
method.org.refcodes.component.OpenException
- Thrown in case opening or accessing an open line
(connection, junction, link) caused problems.public void close() throws org.refcodes.component.CloseException
close
in interface org.refcodes.component.Closable
close
in class org.refcodes.component.impls.AbstractConnectableAutomaton
org.refcodes.component.CloseException
public void releaseAll()
releaseAll
in interface org.refcodes.mixin.Releaseable
protected void pushDatagram(byte aDatagram) throws org.refcodes.component.OpenException
readDatagram()
: use hasDatagram()
to test
beforehand whether there is a datagram available.aDatagram
- The datagram to be pushed at the end of the blocking
queue; to be retrieved with the readDatagram()
method.org.refcodes.component.OpenException
Copyright © 2016. All rights reserved.