public abstract class AbstractShortReceiver extends org.refcodes.component.AbstractConnectableAutomaton implements ShortReceiver
AbstractShortReceiver
is a base abstract implementation of the
ShortReceiver
interface providing common functionality for concrete
real live ShortDatagramReceiver
and ShortBlockReceiver
(=
ShortReceiver
) implementations.
A blocking queue is used internally to which received datagrams are put via
pushDatagram(short)
and which can be retrieved via
readDatagram()
. The pushDatagram(short)
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(short)
to the queue is blocked until elements are taken
from the queue via 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, org.refcodes.component.Closable.CloseBuilder<B extends org.refcodes.component.Closable.CloseBuilder<B>>
Modifier and Type | Field and Description |
---|---|
protected LinkedBlockingQueue<Short> |
_datagramQueue |
static int |
DATAGRAM_QUEUE_SIZE |
Constructor and Description |
---|
AbstractShortReceiver()
Constructs a
AbstractShortReceiver 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. |
AbstractShortReceiver(int aCapacity)
Constructs a
AbstractShortReceiver 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 . |
protected void |
pushDatagram(short aDatagram)
Pushes a datagram into the receiver and puts it into the blocking queue
containing the so far received datagrams.
|
protected void |
pushDatagrams(short[] aDatagrams)
Pushes datagrams into the receiver and puts them into the blocking queue
containing the so far received datagrams.
|
protected void |
pushDatagrams(short[] aDatagrams,
int aOffset,
int aLength)
Pushes datagrams into the receiver and puts them into the blocking queue
containing the so far received datagrams.
|
short |
readDatagram()
Reads (receives) the next short passed from a
DatagramSender
counterpart. |
short[] |
readDatagrams()
Caution: Reads till an
OpenException (or an
InterruptedException in case of blocking till more data is
available) occurs. |
short[] |
readDatagrams(int aBlockSize)
Similar to
ShortBlockProvider.readDatagrams() though at maximum the amount of data
as provided by the block-size is returned. |
void |
releaseAll() |
getConnectionStatus, isClosable, isClosed, isOpenable, isOpened, open, setConnectionStatus
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait
public static final int DATAGRAM_QUEUE_SIZE
protected LinkedBlockingQueue<Short> _datagramQueue
public AbstractShortReceiver()
AbstractShortReceiver
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(short)
to the queue is blocked until elements are
taken from the queue via readDatagram()
.public AbstractShortReceiver(int aCapacity)
AbstractShortReceiver
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(short)
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 short readDatagram() throws org.refcodes.component.OpenException, InterruptedException
DatagramSender
counterpart. In case none short is available, then this method blocks
until one is available.
To prevent blocking, use the ShortDatagramReceiver
extension's
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 short to be read and
Thread.interrupt()
is being called, then the operation is aborted
and an InterruptedException
is thrown.readDatagram
in interface ShortDatagramProvider
ShortDatagramSender
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 short[] readDatagrams() throws org.refcodes.component.OpenException, InterruptedException
OpenException
(or an
InterruptedException
in case of blocking till more data is
available) occurs.
Reads (receives) the next short block passed from a BlockSender
or DatagramSender
counterpart. In case none short block is
available, then this method blocks until one is available.
When a Thread
is waiting for a short to be read and
Thread.interrupt()
is being called, then the operation is aborted
and an InterruptedException
is thrown.readDatagrams
in interface ShortBlockProvider
readDatagrams
in interface ShortProvider
readDatagrams
in interface ShortReceiver
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 short[] readDatagrams(int aBlockSize) throws org.refcodes.component.OpenException, InterruptedException
ShortBlockProvider.readDatagrams()
though at maximum the amount of data
as provided by the block-size is returned.readDatagrams
in interface ShortBlockProvider
readDatagrams
in interface ShortProvider
readDatagrams
in interface ShortReceiver
aBlockSize
- 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 ShortBlockProvider.readDatagrams()
.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
DatagramSender
.
Use the DatagramProvider
extenison's
DatagramProvider.readDatagram()
method for retrieving the
available datagram.hasDatagram
in interface Receivable
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.AbstractConnectableAutomaton
org.refcodes.component.CloseException
public void releaseAll()
releaseAll
in interface org.refcodes.mixin.Releaseable
protected void pushDatagram(short 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
- the open exceptionprotected void pushDatagrams(short[] aDatagrams) throws org.refcodes.component.OpenException
readDatagram()
: use hasDatagram()
to test
beforehand whether there is a datagram available.aDatagrams
- The datagrams to be pushed at the end of the blocking
queue; to be retrieved with the readDatagram()
method.org.refcodes.component.OpenException
- the open exceptionprotected void pushDatagrams(short[] aDatagrams, int aOffset, int aLength) throws org.refcodes.component.OpenException
readDatagram()
: use hasDatagram()
to test
beforehand whether there is a datagram available.aDatagrams
- The datagrams to be pushed at the end of the blocking
queue; to be retrieved with the readDatagram()
method.aOffset
- The offset to start taking data from to be pushed.aLength
- The number of elements to be pushed from the offset
onwards.org.refcodes.component.OpenException
- the open exceptionCopyright © 2018. All rights reserved.