DATA
- The type of the datagram to be operated with.public abstract class AbstractReceiver<DATA extends Serializable> extends org.refcodes.component.impls.AbstractConnectableAutomaton implements Receiver<DATA>
AbstractReceiver
is a base abstract implementation of the
Receiver
interface providing common functionality for concrete real
live Receiver
implementations.
A blocking queue is used internally to which received datagrams are put via
pushDatagram(Serializable)
and which can be retrieved via
readDatagram()
.
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()
.
org.refcodes.component.ConnectableComponent.ConnectableAutomaton
org.refcodes.component.mixins.OpenedAccessor.OpenedMutator, org.refcodes.component.mixins.OpenedAccessor.OpenedProperty
org.refcodes.component.mixins.Closable.CloseAutomaton
Constructor and Description |
---|
AbstractReceiver()
Constructs a
AbstractReceiver with a default sized blocking queue
enabling a maximum of MAX_MESSAGE_QUEUE_SIZE datagrams.
-------------------------------------------------------------------------
Make sure your code fetches the datagrams quick enough to prevent filling
up of the queue. |
AbstractReceiver(int aCapacity)
Constructs a
AbstractReceiver 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
Sender and can
be retrieved via the Receiver.readDatagram() method. |
protected void |
pushDatagram(DATA aDatagram)
Pushes a datagram into the receiver and puts it into the blocking queue
containing the so far received datagrams.
|
DATA |
readDatagram()
Reads (receives) the next datagram passed from a
Sender
counterpart. |
void |
releaseAll() |
getConnectionStatus, isClosable, isClosed, isOpenable, isOpened, open, setConnectionStatus
public AbstractReceiver()
AbstractReceiver
with a default sized blocking queue
enabling a maximum of MAX_MESSAGE_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 AbstractReceiver(int aCapacity)
AbstractReceiver
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 DATA readDatagram() throws org.refcodes.component.traps.OpenException, InterruptedException
Sender
counterpart. In case none datagram is available, then this method blocks
until one is available. To prevent blocking, use the
Receiver.hasDatagram()
method to test beforehand whether a datagram is
available (in a multi threaded usage scenario, Receiver.hasDatagram()
is
not a reliable indicator whether this method will block or not).
When a Thread
is waiting for a datagram to be read and
Thread.interrupt()
is being called, then the operation is aborted
and an InterruptedException
is thrown.readDatagram
in interface Receiver<DATA extends Serializable>
Receiver
counterpart.org.refcodes.component.traps.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.traps.OpenException
Sender
and can
be retrieved via the Receiver.readDatagram()
method.hasDatagram
in interface Receiver<DATA extends Serializable>
Receiver.readDatagram()
method.org.refcodes.component.traps.OpenException
- Thrown in case opening or accessing an open line
(connection, junction, link) caused problems.public void close()
close
in interface org.refcodes.component.mixins.Closable
close
in class org.refcodes.component.impls.AbstractConnectableAutomaton
public void releaseAll()
releaseAll
in interface org.refcodes.mixin.mixins.Releaseable
protected void pushDatagram(DATA aDatagram) throws org.refcodes.component.traps.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.traps.OpenException
Copyright © 2015. All rights reserved.