AbstractChannelAccessChannel (EPICS Jackie 1.0.0 API)

java.lang.Object
- com.aquenos.epics.jackie.client.AbstractChannelAccessChannel

All Implemented Interfaces:

ChannelAccessChannel
```
public abstract class AbstractChannelAccessChannel
extends Object
implements ChannelAccessChannel
```
Abstract base class for ChannelAccessChannel implementations. This base class takes care of handling the connection state listeners and of delegating the various specializations of the get and monitor methods to the one most generic version.

This class uses a HashSet to keep all ChannelAccessConnectionListeners that are registered with this channel. Derived classes should call the updateConnectionState(boolean) method in order to update the connection state and notify the listeners. Implementations may choose to override the notifyConnectionListener(ChannelAccessConnectionListener, boolean) method in order to customize the handling of notifications (e.g. catch certain exceptions possibly thrown by listeners).

All invocations of the various get methods are delegated to the ChannelAccessChannel.get(ChannelAccessValueType, int) method, which has to be implemented by derived classes. All invocations of the various monitor methods are delegated to the ChannelAccessChannel.monitor(ChannelAccessValueType, int, ChannelAccessEventMask) method, which has to be implemented by derived classes.

Author:

Sebastian Marsching

Field Summary

Fields
Modifier and Type	Field and Description
`protected Object`	`connectionStateLock` Synchronization object that this class synchronizes on when modifying the set of registered listeners or triggering the listeners from `updateConnectionState(boolean)`.

Constructor Summary

Constructors
Modifier Constructor and Description

protected AbstractChannelAccessChannel()
Default constructor.

Constructors
Modifier	Constructor and Description
`protected`	`AbstractChannelAccessChannel()` Default constructor.

Method Summary

Methods
Modifier and Type	Method and Description
`boolean`	`addConnectionListener(ChannelAccessConnectionListener listener)` Registers a connection state listener with this channel.
`ListenableFuture<? extends ChannelAccessGettableValue<?>>`	`get(ChannelAccessValueType valueType)` Gets the current value from the channel using the specified type and the channel's `native element count`.
`ListenableFuture<ChannelAccessAlarmAcknowledgementStatus>`	`getAlarmAcknowledgementStatus()` Gets the current value from the channel using the `DBR_STSACK_STRING` data type and the channel's `native element count`.
`ListenableFuture<ChannelAccessAlarmAcknowledgementStatus>`	`getAlarmAcknowledgementStatus(int count)` Gets the current value from the channel using the `DBR_STSACK_STRING` and the specified element count}.
`ListenableFuture<ChannelAccessAlarmOnlyChar>`	`getAlarmChar()` Gets the current value from the channel using the `DBR_STS_CHAR` data type and the channel's `native element count`.
`ListenableFuture<ChannelAccessAlarmOnlyChar>`	`getAlarmChar(int count)` Gets the current value from the channel using the `DBR_STS_CHAR` and the specified element count}.
`ListenableFuture<ChannelAccessAlarmOnlyDouble>`	`getAlarmDouble()` Gets the current value from the channel using the `DBR_STS_DOUBLE` data type and the channel's `native element count`.
`ListenableFuture<ChannelAccessAlarmOnlyDouble>`	`getAlarmDouble(int count)` Gets the current value from the channel using the `DBR_STS_DOUBLE` and the specified element count}.
`ListenableFuture<ChannelAccessAlarmOnlyEnum>`	`getAlarmEnum()` Gets the current value from the channel using the `DBR_STS_ENUM` data type and the channel's `native element count`.
`ListenableFuture<ChannelAccessAlarmOnlyEnum>`	`getAlarmEnum(int count)` Gets the current value from the channel using the `DBR_STS_ENUM` and the specified element count}.
`ListenableFuture<ChannelAccessAlarmOnlyFloat>`	`getAlarmFloat()` Gets the current value from the channel using the `DBR_STS_FLOAT` data type and the channel's `native element count`.
`ListenableFuture<ChannelAccessAlarmOnlyFloat>`	`getAlarmFloat(int count)` Gets the current value from the channel using the `DBR_STS_FLOAT` and the specified element count}.
`ListenableFuture<ChannelAccessAlarmOnlyLong>`	`getAlarmLong()` Gets the current value from the channel using the `DBR_STS_LONG` data type and the channel's `native element count`.
`ListenableFuture<ChannelAccessAlarmOnlyLong>`	`getAlarmLong(int count)` Gets the current value from the channel using the `DBR_STS_LONG` and the specified element count}.
`ListenableFuture<ChannelAccessAlarmOnlyShort>`	`getAlarmShort()` Gets the current value from the channel using the `DBR_STS_SHORT` data type and the channel's `native element count`.
`ListenableFuture<ChannelAccessAlarmOnlyShort>`	`getAlarmShort(int count)` Gets the current value from the channel using the `DBR_STS_SHORT` and the specified element count}.
`ListenableFuture<ChannelAccessAlarmOnlyString>`	`getAlarmString()` Gets the current value from the channel using the `DBR_STS_STRING` data type and the channel's `native element count`.
`ListenableFuture<ChannelAccessAlarmOnlyString>`	`getAlarmString(int count)` Gets the current value from the channel using the `DBR_STS_STRING` and the specified element count}.
`ListenableFuture<ChannelAccessSimpleOnlyChar>`	`getChar()` Gets the current value from the channel using the `DBR_CHAR` data type and the channel's `native element count`.
`ListenableFuture<ChannelAccessSimpleOnlyChar>`	`getChar(int count)` Gets the current value from the channel using the `DBR_CHAR` and the specified element count}.
`ListenableFuture<ChannelAccessClassName>`	`getClassName()` Gets the current value from the channel using the `DBR_CLASS_NAME` data type and the channel's `native element count`.
`ListenableFuture<ChannelAccessClassName>`	`getClassName(int count)` Gets the current value from the channel using the `DBR_CLASS_NAME` and the specified element count}.
`ListenableFuture<ChannelAccessControlsChar>`	`getControlsChar()` Gets the current value from the channel using the `DBR_CTRL_CHAR` data type and the channel's `native element count`.
`ListenableFuture<ChannelAccessControlsChar>`	`getControlsChar(int count)` Gets the current value from the channel using the `DBR_CTRL_CHAR` and the specified element count}.
`ListenableFuture<ChannelAccessControlsDouble>`	`getControlsDouble()` Gets the current value from the channel using the `DBR_CTRL_DOUBLE` data type and the channel's `native element count`.
`ListenableFuture<ChannelAccessControlsDouble>`	`getControlsDouble(int count)` Gets the current value from the channel using the `DBR_CTRL_DOUBLE` and the specified element count}.
`ListenableFuture<ChannelAccessGraphicsEnum>`	`getControlsEnum()` Gets the current value from the channel using the `DBR_CTRL_ENUM` data type and the channel's `native element count`.
`ListenableFuture<ChannelAccessGraphicsEnum>`	`getControlsEnum(int count)` Gets the current value from the channel using the `DBR_CTRL_ENUM` and the specified element count}.
`ListenableFuture<ChannelAccessControlsFloat>`	`getControlsFloat()` Gets the current value from the channel using the `DBR_CTRL_FLOAT` data type and the channel's `native element count`.
`ListenableFuture<ChannelAccessControlsFloat>`	`getControlsFloat(int count)` Gets the current value from the channel using the `DBR_CTRL_FLOAT` and the specified element count}.
`ListenableFuture<ChannelAccessControlsLong>`	`getControlsLong()` Gets the current value from the channel using the `DBR_CTRL_LONG` data type and the channel's `native element count`.
`ListenableFuture<ChannelAccessControlsLong>`	`getControlsLong(int count)` Gets the current value from the channel using the `DBR_CTRL_LONG` and the specified element count}.
`ListenableFuture<ChannelAccessControlsShort>`	`getControlsShort()` Gets the current value from the channel using the `DBR_CTRL_SHORT` data type and the channel's `native element count`.
`ListenableFuture<ChannelAccessControlsShort>`	`getControlsShort(int count)` Gets the current value from the channel using the `DBR_CTRL_SHORT` and the specified element count}.
`ListenableFuture<ChannelAccessAlarmOnlyString>`	`getControlsString()` Gets the current value from the channel using the `DBR_CTRL_STRING` data type and the channel's `native element count`.
`ListenableFuture<ChannelAccessAlarmOnlyString>`	`getControlsString(int count)` Gets the current value from the channel using the `DBR_CTRL_STRING` and the specified element count}.
`ListenableFuture<ChannelAccessSimpleOnlyDouble>`	`getDouble()` Gets the current value from the channel using the `DBR_DOUBLE` data type and the channel's `native element count`.
`ListenableFuture<ChannelAccessSimpleOnlyDouble>`	`getDouble(int count)` Gets the current value from the channel using the `DBR_DOUBLE` and the specified element count}.
`ListenableFuture<ChannelAccessSimpleOnlyEnum>`	`getEnum()` Gets the current value from the channel using the `DBR_ENUM` data type and the channel's `native element count`.
`ListenableFuture<ChannelAccessSimpleOnlyEnum>`	`getEnum(int count)` Gets the current value from the channel using the `DBR_ENUM` and the specified element count}.
`ListenableFuture<ChannelAccessSimpleOnlyFloat>`	`getFloat()` Gets the current value from the channel using the `DBR_FLOAT` data type and the channel's `native element count`.
`ListenableFuture<ChannelAccessSimpleOnlyFloat>`	`getFloat(int count)` Gets the current value from the channel using the `DBR_FLOAT` and the specified element count}.
`ListenableFuture<ChannelAccessGraphicsOnlyChar>`	`getGraphicsChar()` Gets the current value from the channel using the `DBR_GR_CHAR` data type and the channel's `native element count`.
`ListenableFuture<ChannelAccessGraphicsOnlyChar>`	`getGraphicsChar(int count)` Gets the current value from the channel using the `DBR_GR_CHAR` and the specified element count}.
`ListenableFuture<ChannelAccessGraphicsOnlyDouble>`	`getGraphicsDouble()` Gets the current value from the channel using the `DBR_GR_DOUBLE` data type and the channel's `native element count`.
`ListenableFuture<ChannelAccessGraphicsOnlyDouble>`	`getGraphicsDouble(int count)` Gets the current value from the channel using the `DBR_GR_DOUBLE` and the specified element count}.
`ListenableFuture<ChannelAccessGraphicsEnum>`	`getGraphicsEnum()` Gets the current value from the channel using the `DBR_GR_ENUM` data type and the channel's `native element count`.
`ListenableFuture<ChannelAccessGraphicsEnum>`	`getGraphicsEnum(int count)` Gets the current value from the channel using the `DBR_GR_ENUM` and the specified element count}.
`ListenableFuture<ChannelAccessGraphicsOnlyFloat>`	`getGraphicsFloat()` Gets the current value from the channel using the `DBR_GR_FLOAT` data type and the channel's `native element count`.
`ListenableFuture<ChannelAccessGraphicsOnlyFloat>`	`getGraphicsFloat(int count)` Gets the current value from the channel using the `DBR_GR_FLOAT` and the specified element count}.
`ListenableFuture<ChannelAccessGraphicsOnlyLong>`	`getGraphicsLong()` Gets the current value from the channel using the `DBR_GR_LONG` data type and the channel's `native element count`.
`ListenableFuture<ChannelAccessGraphicsOnlyLong>`	`getGraphicsLong(int count)` Gets the current value from the channel using the `DBR_GR_LONG` and the specified element count}.
`ListenableFuture<ChannelAccessGraphicsOnlyShort>`	`getGraphicsShort()` Gets the current value from the channel using the `DBR_GR_SHORT` data type and the channel's `native element count`.
`ListenableFuture<ChannelAccessGraphicsOnlyShort>`	`getGraphicsShort(int count)` Gets the current value from the channel using the `DBR_GR_SHORT` and the specified element count}.
`ListenableFuture<ChannelAccessAlarmOnlyString>`	`getGraphicsString()` Gets the current value from the channel using the `DBR_GR_STRING` data type and the channel's `native element count`.
`ListenableFuture<ChannelAccessAlarmOnlyString>`	`getGraphicsString(int count)` Gets the current value from the channel using the `DBR_GR_STRING` and the specified element count}.
`ListenableFuture<ChannelAccessSimpleOnlyLong>`	`getLong()` Gets the current value from the channel using the `DBR_LONG` data type and the channel's `native element count`.
`ListenableFuture<ChannelAccessSimpleOnlyLong>`	`getLong(int count)` Gets the current value from the channel using the `DBR_LONG` and the specified element count}.
`ListenableFuture<? extends ChannelAccessGettableValue<?>>`	`getNative()` Gets the current value from the channel using the channel's `native data type` and `native element count`.
`ListenableFuture<? extends ChannelAccessGettableValue<?>>`	`getNative(int count)` Gets the current value from the channel using the channel's `native data type` and the specified element count}.
`ListenableFuture<ChannelAccessSimpleOnlyShort>`	`getShort()` Gets the current value from the channel using the `DBR_SHORT` data type and the channel's `native element count`.
`ListenableFuture<ChannelAccessSimpleOnlyShort>`	`getShort(int count)` Gets the current value from the channel using the `DBR_SHORT` and the specified element count}.
`ListenableFuture<ChannelAccessSimpleOnlyString>`	`getString()` Gets the current value from the channel using the `DBR_STRING` data type and the channel's `native element count`.
`ListenableFuture<ChannelAccessSimpleOnlyString>`	`getString(int count)` Gets the current value from the channel using the `DBR_STRING` and the specified element count}.
`ListenableFuture<ChannelAccessTimeChar>`	`getTimeChar()` Gets the current value from the channel using the `DBR_TIME_CHAR` data type and the channel's `native element count`.
`ListenableFuture<ChannelAccessTimeChar>`	`getTimeChar(int count)` Gets the current value from the channel using the `DBR_TIME_CHAR` and the specified element count}.
`ListenableFuture<ChannelAccessTimeDouble>`	`getTimeDouble()` Gets the current value from the channel using the `DBR_TIME_DOUBLE` data type and the channel's `native element count`.
`ListenableFuture<ChannelAccessTimeDouble>`	`getTimeDouble(int count)` Gets the current value from the channel using the `DBR_TIME_DOUBLE` and the specified element count}.
`ListenableFuture<ChannelAccessTimeEnum>`	`getTimeEnum()` Gets the current value from the channel using the `DBR_TIME_ENUM` data type and the channel's `native element count`.
`ListenableFuture<ChannelAccessTimeEnum>`	`getTimeEnum(int count)` Gets the current value from the channel using the `DBR_TIME_ENUM` and the specified element count}.
`ListenableFuture<ChannelAccessTimeFloat>`	`getTimeFloat()` Gets the current value from the channel using the `DBR_TIME_FLOAT` data type and the channel's `native element count`.
`ListenableFuture<ChannelAccessTimeFloat>`	`getTimeFloat(int count)` Gets the current value from the channel using the `DBR_TIME_FLOAT` and the specified element count}.
`ListenableFuture<ChannelAccessTimeLong>`	`getTimeLong()` Gets the current value from the channel using the `DBR_TIME_LONG` data type and the channel's `native element count`.
`ListenableFuture<ChannelAccessTimeLong>`	`getTimeLong(int count)` Gets the current value from the channel using the `DBR_TIME_LONG` and the specified element count}.
`ListenableFuture<ChannelAccessTimeShort>`	`getTimeShort()` Gets the current value from the channel using the `DBR_TIME_SHORT` data type and the channel's `native element count`.
`ListenableFuture<ChannelAccessTimeShort>`	`getTimeShort(int count)` Gets the current value from the channel using the `DBR_TIME_SHORT` and the specified element count}.
`ListenableFuture<ChannelAccessTimeString>`	`getTimeString()` Gets the current value from the channel using the `DBR_TIME_STRING` data type and the channel's `native element count`.
`ListenableFuture<ChannelAccessTimeString>`	`getTimeString(int count)` Gets the current value from the channel using the `DBR_TIME_STRING` and the specified element count}.
`boolean`	`isConnected()` Tells whether this channel is currently connected.
`boolean`	`isConnectedOnce()` Tells whether this channel has been connected at least once.
`ChannelAccessMonitor<? extends ChannelAccessGettableValue<?>>`	`monitor(ChannelAccessValueType valueType)` Creates a monitor for this channel using the specified type, the channel's `native element count`, and the `default event mask`.
`ChannelAccessMonitor<? extends ChannelAccessGettableValue<?>>`	`monitor(ChannelAccessValueType valueType, ChannelAccessEventMask eventMask)` Creates a monitor for this channel using the specified type, the channel's `native element count`, and the specified event mask.
`ChannelAccessMonitor<? extends ChannelAccessGettableValue<?>>`	`monitor(ChannelAccessValueType valueType, int count)` Creates a monitor for this channel using the specified type, the specified element count, and the `default event mask`.
`ChannelAccessMonitor<ChannelAccessAlarmAcknowledgementStatus>`	`monitorAlarmAcknowledgementStatus()` Creates a monitor for this channel using the `DBR_STSACK_STRING` data type, the channel's `native element count`, and the `default event mask`.
`ChannelAccessMonitor<ChannelAccessAlarmAcknowledgementStatus>`	`monitorAlarmAcknowledgementStatus(ChannelAccessEventMask eventMask)` Creates a monitor for this channel using the `DBR_STSACK_STRING` data type, the channel's `native element count`, and the specified event mask.
`ChannelAccessMonitor<ChannelAccessAlarmAcknowledgementStatus>`	`monitorAlarmAcknowledgementStatus(int count)` Creates a monitor for this channel using the `DBR_STSACK_STRING` data type, the specified element count, and the `default event mask`.
`ChannelAccessMonitor<ChannelAccessAlarmAcknowledgementStatus>`	`monitorAlarmAcknowledgementStatus(int count, ChannelAccessEventMask eventMask)` Creates a monitor for this channel using the `DBR_STSACK_STRING` data type, the specified element count, and the specified event mask.
`ChannelAccessMonitor<ChannelAccessAlarmOnlyChar>`	`monitorAlarmChar()` Creates a monitor for this channel using the `DBR_STS_CHAR` data type, the channel's `native element count`, and the `default event mask`.
`ChannelAccessMonitor<ChannelAccessAlarmOnlyChar>`	`monitorAlarmChar(ChannelAccessEventMask eventMask)` Creates a monitor for this channel using the `DBR_STS_CHAR` data type, the channel's `native element count`, and the specified event mask.
`ChannelAccessMonitor<ChannelAccessAlarmOnlyChar>`	`monitorAlarmChar(int count)` Creates a monitor for this channel using the `DBR_STS_CHAR` data type, the specified element count, and the `default event mask`.
`ChannelAccessMonitor<ChannelAccessAlarmOnlyChar>`	`monitorAlarmChar(int count, ChannelAccessEventMask eventMask)` Creates a monitor for this channel using the `DBR_STS_CHAR` data type, the specified element count, and the specified event mask.
`ChannelAccessMonitor<ChannelAccessAlarmOnlyDouble>`	`monitorAlarmDouble()` Creates a monitor for this channel using the `DBR_STS_DOUBLE` data type, the channel's `native element count`, and the `default event mask`.
`ChannelAccessMonitor<ChannelAccessAlarmOnlyDouble>`	`monitorAlarmDouble(ChannelAccessEventMask eventMask)` Creates a monitor for this channel using the `DBR_STS_DOUBLE` data type, the channel's `native element count`, and the specified event mask.
`ChannelAccessMonitor<ChannelAccessAlarmOnlyDouble>`	`monitorAlarmDouble(int count)` Creates a monitor for this channel using the `DBR_STS_DOUBLE` data type, the specified element count, and the `default event mask`.
`ChannelAccessMonitor<ChannelAccessAlarmOnlyDouble>`	`monitorAlarmDouble(int count, ChannelAccessEventMask eventMask)` Creates a monitor for this channel using the `DBR_STS_DOUBLE` data type, the specified element count, and the specified event mask.
`ChannelAccessMonitor<ChannelAccessAlarmOnlyEnum>`	`monitorAlarmEnum()` Creates a monitor for this channel using the `DBR_STS_ENUM` data type, the channel's `native element count`, and the `default event mask`.
`ChannelAccessMonitor<ChannelAccessAlarmOnlyEnum>`	`monitorAlarmEnum(ChannelAccessEventMask eventMask)` Creates a monitor for this channel using the `DBR_STS_ENUM` data type, the channel's `native element count`, and the specified event mask.
`ChannelAccessMonitor<ChannelAccessAlarmOnlyEnum>`	`monitorAlarmEnum(int count)` Creates a monitor for this channel using the `DBR_STS_ENUM` data type, the specified element count, and the `default event mask`.
`ChannelAccessMonitor<ChannelAccessAlarmOnlyEnum>`	`monitorAlarmEnum(int count, ChannelAccessEventMask eventMask)` Creates a monitor for this channel using the `DBR_STS_ENUM` data type, the specified element count, and the specified event mask.
`ChannelAccessMonitor<ChannelAccessAlarmOnlyFloat>`	`monitorAlarmFloat()` Creates a monitor for this channel using the `DBR_STS_FLOAT` data type, the channel's `native element count`, and the `default event mask`.
`ChannelAccessMonitor<ChannelAccessAlarmOnlyFloat>`	`monitorAlarmFloat(ChannelAccessEventMask eventMask)` Creates a monitor for this channel using the `DBR_STS_FLOAT` data type, the channel's `native element count`, and the specified event mask.
`ChannelAccessMonitor<ChannelAccessAlarmOnlyFloat>`	`monitorAlarmFloat(int count)` Creates a monitor for this channel using the `DBR_STS_FLOAT` data type, the specified element count, and the `default event mask`.
`ChannelAccessMonitor<ChannelAccessAlarmOnlyFloat>`	`monitorAlarmFloat(int count, ChannelAccessEventMask eventMask)` Creates a monitor for this channel using the `DBR_STS_FLOAT` data type, the specified element count, and the specified event mask.
`ChannelAccessMonitor<ChannelAccessAlarmOnlyLong>`	`monitorAlarmLong()` Creates a monitor for this channel using the `DBR_STS_LONG` data type, the channel's `native element count`, and the `default event mask`.
`ChannelAccessMonitor<ChannelAccessAlarmOnlyLong>`	`monitorAlarmLong(ChannelAccessEventMask eventMask)` Creates a monitor for this channel using the `DBR_STS_LONG` data type, the channel's `native element count`, and the specified event mask.
`ChannelAccessMonitor<ChannelAccessAlarmOnlyLong>`	`monitorAlarmLong(int count)` Creates a monitor for this channel using the `DBR_STS_LONG` data type, the specified element count, and the `default event mask`.
`ChannelAccessMonitor<ChannelAccessAlarmOnlyLong>`	`monitorAlarmLong(int count, ChannelAccessEventMask eventMask)` Creates a monitor for this channel using the `DBR_STS_LONG` data type, the specified element count, and the specified event mask.
`ChannelAccessMonitor<ChannelAccessAlarmOnlyShort>`	`monitorAlarmShort()` Creates a monitor for this channel using the `DBR_STS_SHORT` data type, the channel's `native element count`, and the `default event mask`.
`ChannelAccessMonitor<ChannelAccessAlarmOnlyShort>`	`monitorAlarmShort(ChannelAccessEventMask eventMask)` Creates a monitor for this channel using the `DBR_STS_SHORT` data type, the channel's `native element count`, and the specified event mask.
`ChannelAccessMonitor<ChannelAccessAlarmOnlyShort>`	`monitorAlarmShort(int count)` Creates a monitor for this channel using the `DBR_STS_SHORT` data type, the specified element count, and the `default event mask`.
`ChannelAccessMonitor<ChannelAccessAlarmOnlyShort>`	`monitorAlarmShort(int count, ChannelAccessEventMask eventMask)` Creates a monitor for this channel using the `DBR_STS_SHORT` data type, the specified element count, and the specified event mask.
`ChannelAccessMonitor<ChannelAccessAlarmOnlyString>`	`monitorAlarmString()` Creates a monitor for this channel using the `DBR_STS_STRING` data type, the channel's `native element count`, and the `default event mask`.
`ChannelAccessMonitor<ChannelAccessAlarmOnlyString>`	`monitorAlarmString(ChannelAccessEventMask eventMask)` Creates a monitor for this channel using the `DBR_STS_STRING` data type, the channel's `native element count`, and the specified event mask.
`ChannelAccessMonitor<ChannelAccessAlarmOnlyString>`	`monitorAlarmString(int count)` Creates a monitor for this channel using the `DBR_STS_STRING` data type, the specified element count, and the `default event mask`.
`ChannelAccessMonitor<ChannelAccessAlarmOnlyString>`	`monitorAlarmString(int count, ChannelAccessEventMask eventMask)` Creates a monitor for this channel using the `DBR_STS_STRING` data type, the specified element count, and the specified event mask.
`ChannelAccessMonitor<ChannelAccessSimpleOnlyChar>`	`monitorChar()` Creates a monitor for this channel using the `DBR_CHAR` data type, the channel's `native element count`, and the `default event mask`.
`ChannelAccessMonitor<ChannelAccessSimpleOnlyChar>`	`monitorChar(ChannelAccessEventMask eventMask)` Creates a monitor for this channel using the `DBR_CHAR` data type, the channel's `native element count`, and the specified event mask.
`ChannelAccessMonitor<ChannelAccessSimpleOnlyChar>`	`monitorChar(int count)` Creates a monitor for this channel using the `DBR_CHAR` data type, the specified element count, and the `default event mask`.
`ChannelAccessMonitor<ChannelAccessSimpleOnlyChar>`	`monitorChar(int count, ChannelAccessEventMask eventMask)` Creates a monitor for this channel using the `DBR_CHAR` data type, the specified element count, and the specified event mask.
`ChannelAccessMonitor<ChannelAccessClassName>`	`monitorClassName()` Creates a monitor for this channel using the `DBR_CLASS_NAME` data type, the channel's `native element count`, and the `default event mask`.
`ChannelAccessMonitor<ChannelAccessClassName>`	`monitorClassName(ChannelAccessEventMask eventMask)` Creates a monitor for this channel using the `DBR_CLASS_NAME` data type, the channel's `native element count`, and the specified event mask.
`ChannelAccessMonitor<ChannelAccessClassName>`	`monitorClassName(int count)` Creates a monitor for this channel using the `DBR_CLASS_NAME` data type, the specified element count, and the `default event mask`.
`ChannelAccessMonitor<ChannelAccessClassName>`	`monitorClassName(int count, ChannelAccessEventMask eventMask)` Creates a monitor for this channel using the `DBR_CLASS_NAME` data type, the specified element count, and the specified event mask.
`ChannelAccessMonitor<ChannelAccessControlsChar>`	`monitorControlsChar()` Creates a monitor for this channel using the `DBR_CTRL_CHAR` data type, the channel's `native element count`, and the `default event mask`.
`ChannelAccessMonitor<ChannelAccessControlsChar>`	`monitorControlsChar(ChannelAccessEventMask eventMask)` Creates a monitor for this channel using the `DBR_CTRL_CHAR` data type, the channel's `native element count`, and the specified event mask.
`ChannelAccessMonitor<ChannelAccessControlsChar>`	`monitorControlsChar(int count)` Creates a monitor for this channel using the `DBR_CTRL_CHAR` data type, the specified element count, and the `default event mask`.
`ChannelAccessMonitor<ChannelAccessControlsChar>`	`monitorControlsChar(int count, ChannelAccessEventMask eventMask)` Creates a monitor for this channel using the `DBR_CTRL_CHAR` data type, the specified element count, and the specified event mask.
`ChannelAccessMonitor<ChannelAccessControlsDouble>`	`monitorControlsDouble()` Creates a monitor for this channel using the `DBR_CTRL_DOUBLE` data type, the channel's `native element count`, and the `default event mask`.
`ChannelAccessMonitor<ChannelAccessControlsDouble>`	`monitorControlsDouble(ChannelAccessEventMask eventMask)` Creates a monitor for this channel using the `DBR_CTRL_DOUBLE` data type, the channel's `native element count`, and the specified event mask.
`ChannelAccessMonitor<ChannelAccessControlsDouble>`	`monitorControlsDouble(int count)` Creates a monitor for this channel using the `DBR_CTRL_DOUBLE` data type, the specified element count, and the `default event mask`.
`ChannelAccessMonitor<ChannelAccessControlsDouble>`	`monitorControlsDouble(int count, ChannelAccessEventMask eventMask)` Creates a monitor for this channel using the `DBR_CTRL_DOUBLE` data type, the specified element count, and the specified event mask.
`ChannelAccessMonitor<ChannelAccessGraphicsEnum>`	`monitorControlsEnum()` Creates a monitor for this channel using the `DBR_CTRL_ENUM` data type, the channel's `native element count`, and the `default event mask`.
`ChannelAccessMonitor<ChannelAccessGraphicsEnum>`	`monitorControlsEnum(ChannelAccessEventMask eventMask)` Creates a monitor for this channel using the `DBR_CTRL_ENUM` data type, the channel's `native element count`, and the specified event mask.
`ChannelAccessMonitor<ChannelAccessGraphicsEnum>`	`monitorControlsEnum(int count)` Creates a monitor for this channel using the `DBR_CTRL_ENUM` data type, the specified element count, and the `default event mask`.
`ChannelAccessMonitor<ChannelAccessGraphicsEnum>`	`monitorControlsEnum(int count, ChannelAccessEventMask eventMask)` Creates a monitor for this channel using the `DBR_CTRL_ENUM` data type, the specified element count, and the specified event mask.
`ChannelAccessMonitor<ChannelAccessControlsFloat>`	`monitorControlsFloat()` Creates a monitor for this channel using the `DBR_CTRL_FLOAT` data type, the channel's `native element count`, and the `default event mask`.
`ChannelAccessMonitor<ChannelAccessControlsFloat>`	`monitorControlsFloat(ChannelAccessEventMask eventMask)` Creates a monitor for this channel using the `DBR_CTRL_FLOAT` data type, the channel's `native element count`, and the specified event mask.
`ChannelAccessMonitor<ChannelAccessControlsFloat>`	`monitorControlsFloat(int count)` Creates a monitor for this channel using the `DBR_CTRL_FLOAT` data type, the specified element count, and the `default event mask`.
`ChannelAccessMonitor<ChannelAccessControlsFloat>`	`monitorControlsFloat(int count, ChannelAccessEventMask eventMask)` Creates a monitor for this channel using the `DBR_CTRL_FLOAT` data type, the specified element count, and the specified event mask.
`ChannelAccessMonitor<ChannelAccessControlsLong>`	`monitorControlsLong()` Creates a monitor for this channel using the `DBR_CTRL_LONG` data type, the channel's `native element count`, and the `default event mask`.
`ChannelAccessMonitor<ChannelAccessControlsLong>`	`monitorControlsLong(ChannelAccessEventMask eventMask)` Creates a monitor for this channel using the `DBR_CTLR_LONG` data type, the channel's `native element count`, and the specified event mask.
`ChannelAccessMonitor<ChannelAccessControlsLong>`	`monitorControlsLong(int count)` Creates a monitor for this channel using the `DBR_CTRL_LONG` data type, the specified element count, and the `default event mask`.
`ChannelAccessMonitor<ChannelAccessControlsLong>`	`monitorControlsLong(int count, ChannelAccessEventMask eventMask)` Creates a monitor for this channel using the `DBR_CTRL_LONG` data type, the specified element count, and the specified event mask.
`ChannelAccessMonitor<ChannelAccessControlsShort>`	`monitorControlsShort()` Creates a monitor for this channel using the `DBR_CTRL_SHORT` data type, the channel's `native element count`, and the `default event mask`.
`ChannelAccessMonitor<ChannelAccessControlsShort>`	`monitorControlsShort(ChannelAccessEventMask eventMask)` Creates a monitor for this channel using the `DBR_CTRL_SHORT` data type, the channel's `native element count`, and the specified event mask.
`ChannelAccessMonitor<ChannelAccessControlsShort>`	`monitorControlsShort(int count)` Creates a monitor for this channel using the `DBR_CTRL_SHORT` data type, the specified element count, and the `default event mask`.
`ChannelAccessMonitor<ChannelAccessControlsShort>`	`monitorControlsShort(int count, ChannelAccessEventMask eventMask)` Creates a monitor for this channel using the `DBR_CTRL_SHORT` data type, the specified element count, and the specified event mask.
`ChannelAccessMonitor<ChannelAccessAlarmOnlyString>`	`monitorControlsString()` Creates a monitor for this channel using the `DBR_CTRL_STRING` data type, the channel's `native element count`, and the `default event mask`.
`ChannelAccessMonitor<ChannelAccessAlarmOnlyString>`	`monitorControlsString(ChannelAccessEventMask eventMask)` Creates a monitor for this channel using the `DBR_CTRL_STRING` data type, the channel's `native element count`, and the specified event mask.
`ChannelAccessMonitor<ChannelAccessAlarmOnlyString>`	`monitorControlsString(int count)` Creates a monitor for this channel using the `DBR_CTRL_STRING` data type, the specified element count, and the `default event mask`.
`ChannelAccessMonitor<ChannelAccessAlarmOnlyString>`	`monitorControlsString(int count, ChannelAccessEventMask eventMask)` Creates a monitor for this channel using the `DBR_CTRL_STRING` data type, the specified element count, and the specified event mask.
`ChannelAccessMonitor<ChannelAccessSimpleOnlyDouble>`	`monitorDouble()` Creates a monitor for this channel using the `DBR_DOUBLE` data type, the channel's `native element count`, and the `default event mask`.
`ChannelAccessMonitor<ChannelAccessSimpleOnlyDouble>`	`monitorDouble(ChannelAccessEventMask eventMask)` Creates a monitor for this channel using the `DBR_DOUBLE` data type, the channel's `native element count`, and the specified event mask.
`ChannelAccessMonitor<ChannelAccessSimpleOnlyDouble>`	`monitorDouble(int count)` Creates a monitor for this channel using the `DBR_DOUBLE` data type, the specified element count, and the `default event mask`.
`ChannelAccessMonitor<ChannelAccessSimpleOnlyDouble>`	`monitorDouble(int count, ChannelAccessEventMask eventMask)` Creates a monitor for this channel using the `DBR_DOUBLE` data type, the specified element count, and the specified event mask.
`ChannelAccessMonitor<ChannelAccessSimpleOnlyEnum>`	`monitorEnum()` Creates a monitor for this channel using the `DBR_ENUM` data type, the channel's `native element count`, and the `default event mask`.
`ChannelAccessMonitor<ChannelAccessSimpleOnlyEnum>`	`monitorEnum(ChannelAccessEventMask eventMask)` Creates a monitor for this channel using the `DBR_ENUM` data type, the channel's `native element count`, and the specified event mask.
`ChannelAccessMonitor<ChannelAccessSimpleOnlyEnum>`	`monitorEnum(int count)` Creates a monitor for this channel using the `DBR_ENUM` data type, the specified element count, and the `default event mask`.
`ChannelAccessMonitor<ChannelAccessSimpleOnlyEnum>`	`monitorEnum(int count, ChannelAccessEventMask eventMask)` Creates a monitor for this channel using the `DBR_ENUM` data type, the specified element count, and the specified event mask.
`ChannelAccessMonitor<ChannelAccessSimpleOnlyFloat>`	`monitorFloat()` Creates a monitor for this channel using the `DBR_FLOAT` data type, the channel's `native element count`, and the `default event mask`.
`ChannelAccessMonitor<ChannelAccessSimpleOnlyFloat>`	`monitorFloat(ChannelAccessEventMask eventMask)` Creates a monitor for this channel using the `DBR_FLOAT` data type, the channel's `native element count`, and the specified event mask.
`ChannelAccessMonitor<ChannelAccessSimpleOnlyFloat>`	`monitorFloat(int count)` Creates a monitor for this channel using the `DBR_FLOAT` data type, the specified element count, and the `default event mask`.
`ChannelAccessMonitor<ChannelAccessSimpleOnlyFloat>`	`monitorFloat(int count, ChannelAccessEventMask eventMask)` Creates a monitor for this channel using the `DBR_FLOAT` data type, the specified element count, and the specified event mask.
`ChannelAccessMonitor<ChannelAccessGraphicsOnlyChar>`	`monitorGraphicsChar()` Creates a monitor for this channel using the `DBR_GR_CHAR` data type, the channel's `native element count`, and the `default event mask`.
`ChannelAccessMonitor<ChannelAccessGraphicsOnlyChar>`	`monitorGraphicsChar(ChannelAccessEventMask eventMask)` Creates a monitor for this channel using the `DBR_GR_CHAR` data type, the channel's `native element count`, and the specified event mask.
`ChannelAccessMonitor<ChannelAccessGraphicsOnlyChar>`	`monitorGraphicsChar(int count)` Creates a monitor for this channel using the `DBR_GR_CHAR` data type, the specified element count, and the `default event mask`.
`ChannelAccessMonitor<ChannelAccessGraphicsOnlyChar>`	`monitorGraphicsChar(int count, ChannelAccessEventMask eventMask)` Creates a monitor for this channel using the `DBR_GR_CHAR` data type, the specified element count, and the specified event mask.
`ChannelAccessMonitor<ChannelAccessGraphicsOnlyDouble>`	`monitorGraphicsDouble()` Creates a monitor for this channel using the `DBR_GR_DOUBLE` data type, the channel's `native element count`, and the `default event mask`.
`ChannelAccessMonitor<ChannelAccessGraphicsOnlyDouble>`	`monitorGraphicsDouble(ChannelAccessEventMask eventMask)` Creates a monitor for this channel using the `DBR_GR_DOUBLE` data type, the channel's `native element count`, and the specified event mask.
`ChannelAccessMonitor<ChannelAccessGraphicsOnlyDouble>`	`monitorGraphicsDouble(int count)` Creates a monitor for this channel using the `DBR_GR_DOUBLE` data type, the specified element count, and the `default event mask`.
`ChannelAccessMonitor<ChannelAccessGraphicsOnlyDouble>`	`monitorGraphicsDouble(int count, ChannelAccessEventMask eventMask)` Creates a monitor for this channel using the `DBR_GR_DOUBLE` data type, the specified element count, and the specified event mask.
`ChannelAccessMonitor<ChannelAccessGraphicsEnum>`	`monitorGraphicsEnum()` Creates a monitor for this channel using the `DBR_GR_ENUM` data type, the channel's `native element count`, and the `default event mask`.
`ChannelAccessMonitor<ChannelAccessGraphicsEnum>`	`monitorGraphicsEnum(ChannelAccessEventMask eventMask)` Creates a monitor for this channel using the `DBR_GR_ENUM` data type, the channel's `native element count`, and the specified event mask.
`ChannelAccessMonitor<ChannelAccessGraphicsEnum>`	`monitorGraphicsEnum(int count)` Creates a monitor for this channel using the `DBR_GR_ENUM` data type, the specified element count, and the `default event mask`.
`ChannelAccessMonitor<ChannelAccessGraphicsEnum>`	`monitorGraphicsEnum(int count, ChannelAccessEventMask eventMask)` Creates a monitor for this channel using the `DBR_GR_ENUM` data type, the specified element count, and the specified event mask.
`ChannelAccessMonitor<ChannelAccessGraphicsOnlyFloat>`	`monitorGraphicsFloat()` Creates a monitor for this channel using the `DBR_GR_FLOAT` data type, the channel's `native element count`, and the `default event mask`.
`ChannelAccessMonitor<ChannelAccessGraphicsOnlyFloat>`	`monitorGraphicsFloat(ChannelAccessEventMask eventMask)` Creates a monitor for this channel using the `DBR_GR_FLOAT` data type, the channel's `native element count`, and the specified event mask.
`ChannelAccessMonitor<ChannelAccessGraphicsOnlyFloat>`	`monitorGraphicsFloat(int count)` Creates a monitor for this channel using the `DBR_GR_FLOAT` data type, the specified element count, and the `default event mask`.
`ChannelAccessMonitor<ChannelAccessGraphicsOnlyFloat>`	`monitorGraphicsFloat(int count, ChannelAccessEventMask eventMask)` Creates a monitor for this channel using the `DBR_GR_FLOAT` data type, the specified element count, and the specified event mask.
`ChannelAccessMonitor<ChannelAccessGraphicsOnlyLong>`	`monitorGraphicsLong()` Creates a monitor for this channel using the `DBR_GR_LONG` data type, the channel's `native element count`, and the `default event mask`.
`ChannelAccessMonitor<ChannelAccessGraphicsOnlyLong>`	`monitorGraphicsLong(ChannelAccessEventMask eventMask)` Creates a monitor for this channel using the `DBR_GR_LONG` data type, the channel's `native element count`, and the specified event mask.
`ChannelAccessMonitor<ChannelAccessGraphicsOnlyLong>`	`monitorGraphicsLong(int count)` Creates a monitor for this channel using the `DBR_GR_LONG` data type, the specified element count, and the `default event mask`.
`ChannelAccessMonitor<ChannelAccessGraphicsOnlyLong>`	`monitorGraphicsLong(int count, ChannelAccessEventMask eventMask)` Creates a monitor for this channel using the `DBR_GR_LONG` data type, the specified element count, and the specified event mask.
`ChannelAccessMonitor<ChannelAccessGraphicsOnlyShort>`	`monitorGraphicsShort()` Creates a monitor for this channel using the `DBR_GR_SHORT` data type, the channel's `native element count`, and the `default event mask`.
`ChannelAccessMonitor<ChannelAccessGraphicsOnlyShort>`	`monitorGraphicsShort(ChannelAccessEventMask eventMask)` Creates a monitor for this channel using the `DBR_GR_SHORT` data type, the channel's `native element count`, and the specified event mask.
`ChannelAccessMonitor<ChannelAccessGraphicsOnlyShort>`	`monitorGraphicsShort(int count)` Creates a monitor for this channel using the `DBR_GR_SHORT` data type, the specified element count, and the `default event mask`.
`ChannelAccessMonitor<ChannelAccessGraphicsOnlyShort>`	`monitorGraphicsShort(int count, ChannelAccessEventMask eventMask)` Creates a monitor for this channel using the `DBR_GR_SHORT` data type, the specified element count, and the specified event mask.
`ChannelAccessMonitor<ChannelAccessAlarmOnlyString>`	`monitorGraphicsString()` Creates a monitor for this channel using the `DBR_GR_STRING` data type, the channel's `native element count`, and the `default event mask`.
`ChannelAccessMonitor<ChannelAccessAlarmOnlyString>`	`monitorGraphicsString(ChannelAccessEventMask eventMask)` Creates a monitor for this channel using the `DBR_GR_STRING` data type, the channel's `native element count`, and the specified event mask.
`ChannelAccessMonitor<ChannelAccessAlarmOnlyString>`	`monitorGraphicsString(int count)` Creates a monitor for this channel using the `DBR_GR_STRING` data type, the specified element count, and the `default event mask`.
`ChannelAccessMonitor<ChannelAccessAlarmOnlyString>`	`monitorGraphicsString(int count, ChannelAccessEventMask eventMask)` Creates a monitor for this channel using the `DBR_GR_STRING` data type, the specified element count, and the specified event mask.
`ChannelAccessMonitor<ChannelAccessSimpleOnlyLong>`	`monitorLong()` Creates a monitor for this channel using the `DBR_LONG` data type, the channel's `native element count`, and the `default event mask`.
`ChannelAccessMonitor<ChannelAccessSimpleOnlyLong>`	`monitorLong(ChannelAccessEventMask eventMask)` Creates a monitor for this channel using the `DBR_LONG` data type, the channel's `native element count`, and the specified event mask.
`ChannelAccessMonitor<ChannelAccessSimpleOnlyLong>`	`monitorLong(int count)` Creates a monitor for this channel using the `DBR_LONG` data type, the specified element count, and the `default event mask`.
`ChannelAccessMonitor<ChannelAccessSimpleOnlyLong>`	`monitorLong(int count, ChannelAccessEventMask eventMask)` Creates a monitor for this channel using the `DBR_LONG` data type, the specified element count, and the specified event mask.
`ChannelAccessMonitor<? extends ChannelAccessGettableValue<?>>`	`monitorNative()` Creates a monitor for this channel using the channel's `native data type`, the channel's `native element count`, and the `default event mask`.
`ChannelAccessMonitor<? extends ChannelAccessGettableValue<?>>`	`monitorNative(ChannelAccessEventMask eventMask)` Creates a monitor for this channel using the channel's `native data type`, the channel's `native element count`, and the specified event mask.
`ChannelAccessMonitor<? extends ChannelAccessGettableValue<?>>`	`monitorNative(int count)` Creates a monitor for this channel using the channel's `native data type`, the specified element count, and the `default event mask`.
`ChannelAccessMonitor<? extends ChannelAccessGettableValue<?>>`	`monitorNative(int count, ChannelAccessEventMask eventMask)` Creates a monitor for this channel using the channel's `native data type`, the specified element count, and the specified event mask.
`ChannelAccessMonitor<ChannelAccessSimpleOnlyShort>`	`monitorShort()` Creates a monitor for this channel using the `DBR_SHORT` data type, the channel's `native element count`, and the `default event mask`.
`ChannelAccessMonitor<ChannelAccessSimpleOnlyShort>`	`monitorShort(ChannelAccessEventMask eventMask)` Creates a monitor for this channel using the `DBR_SHORT` data type, the channel's `native element count`, and the specified event mask.
`ChannelAccessMonitor<ChannelAccessSimpleOnlyShort>`	`monitorShort(int count)` Creates a monitor for this channel using the `DBR_SHORT` data type, the specified element count, and the `default event mask`.
`ChannelAccessMonitor<ChannelAccessSimpleOnlyShort>`	`monitorShort(int count, ChannelAccessEventMask eventMask)` Creates a monitor for this channel using the `DBR_SHORT` data type, the specified element count, and the specified event mask.
`ChannelAccessMonitor<ChannelAccessSimpleOnlyString>`	`monitorString()` Creates a monitor for this channel using the `DBR_STRING` data type, the channel's `native element count`, and the `default event mask`.
`ChannelAccessMonitor<ChannelAccessSimpleOnlyString>`	`monitorString(ChannelAccessEventMask eventMask)` Creates a monitor for this channel using the `DBR_STRING` data type, the channel's `native element count`, and the specified event mask.
`ChannelAccessMonitor<ChannelAccessSimpleOnlyString>`	`monitorString(int count)` Creates a monitor for this channel using the `DBR_STRING` data type, the specified element count, and the `default event mask`.
`ChannelAccessMonitor<ChannelAccessSimpleOnlyString>`	`monitorString(int count, ChannelAccessEventMask eventMask)` Creates a monitor for this channel using the `DBR_STRING` data type, the specified element count, and the specified event mask.
`ChannelAccessMonitor<ChannelAccessTimeChar>`	`monitorTimeChar()` Creates a monitor for this channel using the `DBR_TIME_CHAR` data type, the channel's `native element count`, and the `default event mask`.
`ChannelAccessMonitor<ChannelAccessTimeChar>`	`monitorTimeChar(ChannelAccessEventMask eventMask)` Creates a monitor for this channel using the `DBR_TIME_CHAR` data type, the channel's `native element count`, and the specified event mask.
`ChannelAccessMonitor<ChannelAccessTimeChar>`	`monitorTimeChar(int count)` Creates a monitor for this channel using the `DBR_TIME_CHAR` data type, the specified element count, and the `default event mask`.
`ChannelAccessMonitor<ChannelAccessTimeChar>`	`monitorTimeChar(int count, ChannelAccessEventMask eventMask)` Creates a monitor for this channel using the `DBR_TIME_CHAR` data type, the specified element count, and the specified event mask.
`ChannelAccessMonitor<ChannelAccessTimeDouble>`	`monitorTimeDouble()` Creates a monitor for this channel using the `DBR_TIME_DOUBLE` data type, the channel's `native element count`, and the `default event mask`.
`ChannelAccessMonitor<ChannelAccessTimeDouble>`	`monitorTimeDouble(ChannelAccessEventMask eventMask)` Creates a monitor for this channel using the `DBR_TIME_DOUBLE` data type, the channel's `native element count`, and the specified event mask.
`ChannelAccessMonitor<ChannelAccessTimeDouble>`	`monitorTimeDouble(int count)` Creates a monitor for this channel using the `DBR_TIME_DOUBLE` data type, the specified element count, and the `default event mask`.
`ChannelAccessMonitor<ChannelAccessTimeDouble>`	`monitorTimeDouble(int count, ChannelAccessEventMask eventMask)` Creates a monitor for this channel using the `DBR_TIME_DOUBLE` data type, the specified element count, and the specified event mask.
`ChannelAccessMonitor<ChannelAccessTimeEnum>`	`monitorTimeEnum()` Creates a monitor for this channel using the `DBR_TIME_ENUM` data type, the channel's `native element count`, and the `default event mask`.
`ChannelAccessMonitor<ChannelAccessTimeEnum>`	`monitorTimeEnum(ChannelAccessEventMask eventMask)` Creates a monitor for this channel using the `DBR_TIME_ENUM` data type, the channel's `native element count`, and the specified event mask.
`ChannelAccessMonitor<ChannelAccessTimeEnum>`	`monitorTimeEnum(int count)` Creates a monitor for this channel using the `DBR_TIME_ENUM` data type, the specified element count, and the `default event mask`.
`ChannelAccessMonitor<ChannelAccessTimeEnum>`	`monitorTimeEnum(int count, ChannelAccessEventMask eventMask)` Creates a monitor for this channel using the `DBR_TIME_ENUM` data type, the specified element count, and the specified event mask.
`ChannelAccessMonitor<ChannelAccessTimeFloat>`	`monitorTimeFloat()` Creates a monitor for this channel using the `DBR_TIME_FLOAT` data type, the channel's `native element count`, and the `default event mask`.
`ChannelAccessMonitor<ChannelAccessTimeFloat>`	`monitorTimeFloat(ChannelAccessEventMask eventMask)` Creates a monitor for this channel using the `DBR_TIME_FLOAT` data type, the channel's `native element count`, and the specified event mask.
`ChannelAccessMonitor<ChannelAccessTimeFloat>`	`monitorTimeFloat(int count)` Creates a monitor for this channel using the `DBR_TIME_FLOAT` data type, the specified element count, and the `default event mask`.
`ChannelAccessMonitor<ChannelAccessTimeFloat>`	`monitorTimeFloat(int count, ChannelAccessEventMask eventMask)` Creates a monitor for this channel using the `DBR_TIME_FLOAT` data type, the specified element count, and the specified event mask.
`ChannelAccessMonitor<ChannelAccessTimeLong>`	`monitorTimeLong()` Creates a monitor for this channel using the `DBR_TIME_LONG` data type, the channel's `native element count`, and the `default event mask`.
`ChannelAccessMonitor<ChannelAccessTimeLong>`	`monitorTimeLong(ChannelAccessEventMask eventMask)` Creates a monitor for this channel using the `DBR_TIME_LONG` data type, the channel's `native element count`, and the specified event mask.
`ChannelAccessMonitor<ChannelAccessTimeLong>`	`monitorTimeLong(int count)` Creates a monitor for this channel using the `DBR_TIME_LONG` data type, the specified element count, and the `default event mask`.
`ChannelAccessMonitor<ChannelAccessTimeLong>`	`monitorTimeLong(int count, ChannelAccessEventMask eventMask)` Creates a monitor for this channel using the `DBR_TIME_LONG` data type, the specified element count, and the specified event mask.
`ChannelAccessMonitor<ChannelAccessTimeShort>`	`monitorTimeShort()` Creates a monitor for this channel using the `DBR_TIME_SHORT` data type, the channel's `native element count`, and the `default event mask`.
`ChannelAccessMonitor<ChannelAccessTimeShort>`	`monitorTimeShort(ChannelAccessEventMask eventMask)` Creates a monitor for this channel using the `DBR_TIME_SHORT` data type, the channel's `native element count`, and the specified event mask.
`ChannelAccessMonitor<ChannelAccessTimeShort>`	`monitorTimeShort(int count)` Creates a monitor for this channel using the `DBR_TIME_SHORT` data type, the specified element count, and the `default event mask`.
`ChannelAccessMonitor<ChannelAccessTimeShort>`	`monitorTimeShort(int count, ChannelAccessEventMask eventMask)` Creates a monitor for this channel using the `DBR_TIME_SHORT` data type, the specified element count, and the specified event mask.
`ChannelAccessMonitor<ChannelAccessTimeString>`	`monitorTimeString()` Creates a monitor for this channel using the `DBR_TIME_STRING` data type, the channel's `native element count`, and the `default event mask`.
`ChannelAccessMonitor<ChannelAccessTimeString>`	`monitorTimeString(ChannelAccessEventMask eventMask)` Creates a monitor for this channel using the `DBR_TIME_STRING` data type, the channel's `native element count`, and the specified event mask.
`ChannelAccessMonitor<ChannelAccessTimeString>`	`monitorTimeString(int count)` Creates a monitor for this channel using the `DBR_TIME_STRING` data type, the specified element count, and the `default event mask`.
`ChannelAccessMonitor<ChannelAccessTimeString>`	`monitorTimeString(int count, ChannelAccessEventMask eventMask)` Creates a monitor for this channel using the `DBR_TIME_STRING` data type, the specified element count, and the specified event mask.
`protected void`	`notifyConnectionListener(ChannelAccessConnectionListener listener, boolean nowConnected)` Notifies a connection listener.
`protected void`	`notifyWaitForConnectionStateFutureListener(ListenableFuture<Boolean> future, FutureCompletionListener<? super Boolean> listener)` Notifies a completion listener that has been registered with a listenable future returned by `waitForConnectionState(boolean)`.
`ListenableFuture<Void>`	`putAcknowledgeAlarm(ChannelAccessAlarmSeverity acknowledgeAlarmSeverity)` Puts the specified `DBR_PUT_ACKS` to the channel.
`ListenableFuture<Void>`	`putChar(byte value)` Puts the specified single element `DBR_CHAR` to the channel.
`ListenableFuture<Void>`	`putChar(byte[] value)` Puts the specified array to the channel as a `DBR_CHAR`.
`ListenableFuture<Void>`	`putConfigureAcknowledgeTransientAlarms(boolean explicitlyAcknowledgeTransientAlarms)` Puts the specified `DBR_PUT_ACKT` to the channel.
`ListenableFuture<Void>`	`putDouble(double value)` Puts the specified single element `DBR_DOUBLE` to the channel.
`ListenableFuture<Void>`	`putDouble(double[] value)` Puts the specified array to the channel as a `DBR_DOUBLE`.
`ListenableFuture<Void>`	`putEnum(short value)` Puts the specified single element `DBR_ENUM` to the channel.
`ListenableFuture<Void>`	`putEnum(short[] value)` Puts the specified array to the channel as a `DBR_ENUM`.
`ListenableFuture<Void>`	`putFloat(float value)` Puts the specified single element `DBR_FLOAT` to the channel.
`ListenableFuture<Void>`	`putFloat(float[] value)` Puts the specified array to the channel as a `DBR_FLOAT`.
`ListenableFuture<Void>`	`putLong(int value)` Puts the specified single element `DBR_LONG` to the channel.
`ListenableFuture<Void>`	`putLong(int[] value)` Puts the specified array to the channel as a `DBR_LONG`.
`ListenableFuture<Void>`	`putShort(short value)` Puts the specified single element `DBR_SHORT` to the channel.
`ListenableFuture<Void>`	`putShort(short[] value)` Puts the specified array to the channel as a `DBR_SHORT`.
`ListenableFuture<Void>`	`putString(Collection<String> value)` Puts the specified collection to the channel as a `DBR_STRING`.
`ListenableFuture<Void>`	`putString(String value)` Puts the specified single element `DBR_STRING` to the channel.
`ListenableFuture<Void>`	`putString(String[] value)` Puts the specified array to the channel as a `DBR_STRING`.
`boolean`	`removeConnectionListener(ChannelAccessConnectionListener listener)` Unregisters a connection state listener from this channel.
`protected void`	`updateConnectionState(boolean nowConnected)` Updates the connection state and notifies the connection state listeners.
`ListenableFuture<Boolean>`	`waitForConnectionState(boolean connectionState)` Returns a listenable future that completes when the specified connection state is established.

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Methods inherited from interface com.aquenos.epics.jackie.client.ChannelAccessChannel
destroy, get, getClient, getName, getNativeCount, getNativeDataType, isDestroyed, isMayRead, isMayWrite, monitor, put

- Field Detail
  - connectionStateLock
```
protected final Object connectionStateLock
```
    Synchronization object that this class synchronizes on when modifying the set of registered listeners or triggering the listeners from updateConnectionState(boolean).
- Constructor Detail
  - AbstractChannelAccessChannel
```
protected AbstractChannelAccessChannel()
```
    Default constructor. This constructor is supposed to be used by classes that inherit from this class. It initializes the channel with the disconnected state and an empty set of connection listeners.
- Method Detail
  - updateConnectionState
```
protected void updateConnectionState(boolean nowConnected)
```
    Updates the connection state and notifies the connection state listeners. This method delegates calling each listener to notifyConnectionListener(ChannelAccessConnectionListener, boolean) , so that derived classes can take extra precautions (e.g. catch certain exceptions thrown by a listener). Accordingly, setting the result of futures created for calls to the waitForConnectionState(boolean) method is delegated to the notifyWaitForConnectionStateFutureListener(ListenableFuture, FutureCompletionListener) method.
    
    This method should be called by derived classes whenever the connection state of the channel changes.
    
    Parameters:
    nowConnected - true if the channel is now connected, false if it is now disconnected.
  - notifyConnectionListener
```
protected void notifyConnectionListener(ChannelAccessConnectionListener listener,
                            boolean nowConnected)
```
    Notifies a connection listener. This method can be overridden in order to modify how the listener is called. For example, some implementations might want to catch certain exceptions thrown by a listener.
    
    Parameters:
    listener - the listener that should be notified. Notification should happen by calling the listeners completed() method, passing a reference to this future instance.
    nowConnected - true if the channel is now connected, false if it is now disconnected.
  - notifyWaitForConnectionStateFutureListener
```
protected void notifyWaitForConnectionStateFutureListener(ListenableFuture<Boolean> future,
                                              FutureCompletionListener<? super Boolean> listener)
```
    Notifies a completion listener that has been registered with a listenable future returned by waitForConnectionState(boolean).
    
    This method can be overridden in order to modify how the listener is called. For example, some implementations might want to catch certain exceptions thrown by a listener.
    
    Parameters:
    future - future that was returned by waitForConnectionState(boolean) that completed.
    listener - listener that has been registered with the future and shall be notify. This method must call the listener's completed(...) method, passing the future.
  - isConnected
```
public boolean isConnected()
```
    Description copied from interface: ChannelAccessChannel
    
    Tells whether this channel is currently connected.
    
    Specified by:
    
    isConnected in interface ChannelAccessChannel
    
    Returns:
    true if the channel is currently connected, false if it is currently disconnected.
    See Also:
    ChannelAccessChannel.isConnectedOnce()
  - isConnectedOnce
```
public boolean isConnectedOnce()
```
    Description copied from interface: ChannelAccessChannel
    
    Tells whether this channel has been connected at least once.
    
    Specified by:
    
    isConnectedOnce in interface ChannelAccessChannel
    
    Returns:
    true if this channel is currently connected or has previously been connected, false otherwise.
    See Also:
    ChannelAccessChannel.isConnected()
  - addConnectionListener
```
public boolean addConnectionListener(ChannelAccessConnectionListener listener)
```
    Description copied from interface: ChannelAccessChannel
    
    Registers a connection state listener with this channel. The listener will be notified when this channel's connection state changes. When the listener is added, it is called once to notify it of the current connection state.
    
    If the specified listener is already registered with this channel, no action is taken and this method returns false.
    
    Important note: Typically, the listener is executed by the thread that performs network I/O. For this reason, it is important that the listener does not block or perform any long-running operations. Instead, the listener should delegate any such operation to a different thread (e.g. using an Executor). Any violation of this rule might result in unexpected or unpredictable behavior. In particular, a blocking listener might cause a dead-lock, which results in the whole Channel Access client being stalled indefinitely.
    
    If the calling code is not interested in receiving permanent status updates and only wants to wait for a certain connection state to be established, ChannelAccessChannel.waitForConnectionState(boolean) might be a simpler alternative to this method.
    
    Specified by:
    
    addConnectionListener in interface ChannelAccessChannel
    
    Parameters:
    listener - listener to be registered with this channel. Must not be null.
    
    Returns:
    true if the listener has been added, false if the listener has already been added earlier.
    See Also:
    ChannelAccessChannel.removeConnectionListener(ChannelAccessConnectionListener), ChannelAccessChannel.waitForConnectionState(boolean)
  - removeConnectionListener
```
public boolean removeConnectionListener(ChannelAccessConnectionListener listener)
```
    Description copied from interface: ChannelAccessChannel
    
    Unregisters a connection state listener from this channel. After being removed, the listener will not be notified of further connection state changes.
    
    If the specified listener has already been removed from this channel or has never been added, no action is taken and this method returns false.
    
    Specified by:
    
    removeConnectionListener in interface ChannelAccessChannel
    
    Parameters:
    listener - listener to be unregistered from this channel.
    
    Returns:
    true if the listener has been removed, false if the listener has already been removed earlier or if it has never been added.
    See Also:
    ChannelAccessChannel.addConnectionListener(ChannelAccessConnectionListener)
  - waitForConnectionState
```
public ListenableFuture<Boolean> waitForConnectionState(boolean connectionState)
```
    Description copied from interface: ChannelAccessChannel
    
    Returns a listenable future that completes when the specified connection state is established. This method can be used if certain actions are to be delayed until the channel is connected or disconnected.
    
    If the channel is already in the specified connection state, the future returned by this method completes immediately.
    
    Due to the asynchronous nature of connection events, there is no guarantee that the channel is still in the specified connection state when the future has completed. It is possible that the channel again changed its state after first switching to the desired state. If the code waiting for the future detects such a situation, it should simply make another call to this method to wait for the connection state to change again.
    
    Specified by:
    
    waitForConnectionState in interface ChannelAccessChannel
    
    Parameters:
    connectionState - desired connection state. If true, the future returned by this method completes when the channel is connected. If false, the future returned by this method completes when the channel is disconnected.
    
    Returns:
    listenable future that completes when the channel changes to the specified connectionState. If the channel already is in the specified connectionState, the future completes immediately. The completed future's value will be the connection state at the time when it completed (always the specified connectionState).
  - get
```
public ListenableFuture<? extends ChannelAccessGettableValue<?>> get(ChannelAccessValueType valueType)
```
    Description copied from interface: ChannelAccessChannel
    
    Gets the current value from the channel using the specified type and the channel's native element count.
    
    Due to a get operation's asynchronous nature, the result is not returned right away, but a future that can be used to wait on the operation and get its result is returned.
    
    Errors are typically indicated by an exception that is wrapped in an ExecutionException that is thrown by the future. Only errors in the parameters to this method or a destroyed channel will result in an immediate exception thrown by this method.
    
    Specified by:
    
    get in interface ChannelAccessChannel
    
    Parameters:
    valueType - type of the value that shall be returned by the server. The specified type must be allowed for get operations ( ChannelAccessValueType.isGettable() must return true). If null, the channel's native data type is used.
    
    Returns:
    listenable future that can be used to retrieve the result of the operation and to be notified when the operation finishes. The type of the value returned by the future can be expected to match the specified valueType.
  - getNative
```
public ListenableFuture<? extends ChannelAccessGettableValue<?>> getNative()
```
    Description copied from interface: ChannelAccessChannel
    
    Gets the current value from the channel using the channel's native data type and native element count.
    
    Due to a get operation's asynchronous nature, the result is not returned right away, but a future that can be used to wait on the operation and get its result is returned.
    
    Errors are typically indicated by an exception that is wrapped in an ExecutionException that is thrown by the future. Only a destroyed channel will result in an immediate exception thrown by this method.
    
    Specified by:
    
    getNative in interface ChannelAccessChannel
    
    Returns:
    listenable future that can be used to retrieve the result of the operation and to be notified when the operation finishes.
  - getNative
```
public ListenableFuture<? extends ChannelAccessGettableValue<?>> getNative(int count)
```
    Description copied from interface: ChannelAccessChannel
    
    Gets the current value from the channel using the channel's native data type and the specified element count}.
    
    Due to a get operation's asynchronous nature, the result is not returned right away, but a future that can be used to wait on the operation and get its result is returned.
    
    Errors are typically indicated by an exception that is wrapped in an ExecutionException that is thrown by the future. Only errors in the parameters to this method or a destroyed channel will result in an immediate exception thrown by this method.
    
    Specified by:
    
    getNative in interface ChannelAccessChannel
    
    Parameters:
    count - number of elements to request from the server. Must be positive or zero. A value of zero is interpreted as the channel's native element count. If the specified number exceeds the channel's native element count, the get operation only returns the number of elements that is equal to the channel's native element count.
    
    Returns:
    listenable future that can be used to retrieve the result of the operation and to be notified when the operation finishes.
  - getString
```
public ListenableFuture<ChannelAccessSimpleOnlyString> getString()
```
    Description copied from interface: ChannelAccessChannel
    
    Gets the current value from the channel using the DBR_STRING data type and the channel's native element count.
    
    Due to a get operation's asynchronous nature, the result is not returned right away, but a future that can be used to wait on the operation and get its result is returned.
    
    Errors are typically indicated by an exception that is wrapped in an ExecutionException that is thrown by the future. Only a destroyed channel will result in an immediate exception thrown by this method.
    
    Specified by:
    
    getString in interface ChannelAccessChannel
    
    Returns:
    listenable future that can be used to retrieve the result of the operation and to be notified when the operation finishes.
  - getString
```
public ListenableFuture<ChannelAccessSimpleOnlyString> getString(int count)
```
    Description copied from interface: ChannelAccessChannel
    
    Gets the current value from the channel using the DBR_STRING and the specified element count}.
    
    Due to a get operation's asynchronous nature, the result is not returned right away, but a future that can be used to wait on the operation and get its result is returned.
    
    Errors are typically indicated by an exception that is wrapped in an ExecutionException that is thrown by the future. Only errors in the parameters to this method or a destroyed channel will result in an immediate exception thrown by this method.
    
    Specified by:
    
    getString in interface ChannelAccessChannel
    
    Parameters:
    count - number of elements to request from the server. Must be positive or zero. A value of zero is interpreted as the channel's native element count. If the specified number exceeds the channel's native element count, the get operation only returns the number of elements that is equal to the channel's native element count.
    
    Returns:
    listenable future that can be used to retrieve the result of the operation and to be notified when the operation finishes.
  - getAlarmString
```
public ListenableFuture<ChannelAccessAlarmOnlyString> getAlarmString()
```
    Description copied from interface: ChannelAccessChannel
    
    Gets the current value from the channel using the DBR_STS_STRING data type and the channel's native element count.
    
    Due to a get operation's asynchronous nature, the result is not returned right away, but a future that can be used to wait on the operation and get its result is returned.
    
    Errors are typically indicated by an exception that is wrapped in an ExecutionException that is thrown by the future. Only a destroyed channel will result in an immediate exception thrown by this method.
    
    Specified by:
    
    getAlarmString in interface ChannelAccessChannel
    
    Returns:
    listenable future that can be used to retrieve the result of the operation and to be notified when the operation finishes.
  - getAlarmString
```
public ListenableFuture<ChannelAccessAlarmOnlyString> getAlarmString(int count)
```
    Description copied from interface: ChannelAccessChannel
    
    Gets the current value from the channel using the DBR_STS_STRING and the specified element count}.
    
    Due to a get operation's asynchronous nature, the result is not returned right away, but a future that can be used to wait on the operation and get its result is returned.
    
    Errors are typically indicated by an exception that is wrapped in an ExecutionException that is thrown by the future. Only errors in the parameters to this method or a destroyed channel will result in an immediate exception thrown by this method.
    
    Specified by:
    
    getAlarmString in interface ChannelAccessChannel
    
    Parameters:
    count - number of elements to request from the server. Must be positive or zero. A value of zero is interpreted as the channel's native element count. If the specified number exceeds the channel's native element count, the get operation only returns the number of elements that is equal to the channel's native element count.
    
    Returns:
    listenable future that can be used to retrieve the result of the operation and to be notified when the operation finishes.
  - getTimeString
```
public ListenableFuture<ChannelAccessTimeString> getTimeString()
```
    Description copied from interface: ChannelAccessChannel
    
    Gets the current value from the channel using the DBR_TIME_STRING data type and the channel's native element count.
    
    Due to a get operation's asynchronous nature, the result is not returned right away, but a future that can be used to wait on the operation and get its result is returned.
    
    Errors are typically indicated by an exception that is wrapped in an ExecutionException that is thrown by the future. Only a destroyed channel will result in an immediate exception thrown by this method.
    
    Specified by:
    
    getTimeString in interface ChannelAccessChannel
    
    Returns:
    listenable future that can be used to retrieve the result of the operation and to be notified when the operation finishes.
  - getTimeString
```
public ListenableFuture<ChannelAccessTimeString> getTimeString(int count)
```
    Description copied from interface: ChannelAccessChannel
    
    Gets the current value from the channel using the DBR_TIME_STRING and the specified element count}.
    
    Due to a get operation's asynchronous nature, the result is not returned right away, but a future that can be used to wait on the operation and get its result is returned.
    
    Errors are typically indicated by an exception that is wrapped in an ExecutionException that is thrown by the future. Only errors in the parameters to this method or a destroyed channel will result in an immediate exception thrown by this method.
    
    Specified by:
    
    getTimeString in interface ChannelAccessChannel
    
    Parameters:
    count - number of elements to request from the server. Must be positive or zero. A value of zero is interpreted as the channel's native element count. If the specified number exceeds the channel's native element count, the get operation only returns the number of elements that is equal to the channel's native element count.
    
    Returns:
    listenable future that can be used to retrieve the result of the operation and to be notified when the operation finishes.
  - getGraphicsString
```
public ListenableFuture<ChannelAccessAlarmOnlyString> getGraphicsString()
```
    Description copied from interface: ChannelAccessChannel
    
    Gets the current value from the channel using the DBR_GR_STRING data type and the channel's native element count.
    
    Due to a get operation's asynchronous nature, the result is not returned right away, but a future that can be used to wait on the operation and get its result is returned.
    
    Errors are typically indicated by an exception that is wrapped in an ExecutionException that is thrown by the future. Only a destroyed channel will result in an immediate exception thrown by this method.
    
    Specified by:
    
    getGraphicsString in interface ChannelAccessChannel
    
    Returns:
    listenable future that can be used to retrieve the result of the operation and to be notified when the operation finishes.
  - getGraphicsString
```
public ListenableFuture<ChannelAccessAlarmOnlyString> getGraphicsString(int count)
```
    Description copied from interface: ChannelAccessChannel
    
    Gets the current value from the channel using the DBR_GR_STRING and the specified element count}.
    
    Due to a get operation's asynchronous nature, the result is not returned right away, but a future that can be used to wait on the operation and get its result is returned.
    
    Errors are typically indicated by an exception that is wrapped in an ExecutionException that is thrown by the future. Only errors in the parameters to this method or a destroyed channel will result in an immediate exception thrown by this method.
    
    Specified by:
    
    getGraphicsString in interface ChannelAccessChannel
    
    Parameters:
    count - number of elements to request from the server. Must be positive or zero. A value of zero is interpreted as the channel's native element count. If the specified number exceeds the channel's native element count, the get operation only returns the number of elements that is equal to the channel's native element count.
    
    Returns:
    listenable future that can be used to retrieve the result of the operation and to be notified when the operation finishes.
  - getControlsString
```
public ListenableFuture<ChannelAccessAlarmOnlyString> getControlsString()
```
    Description copied from interface: ChannelAccessChannel
    
    Gets the current value from the channel using the DBR_CTRL_STRING data type and the channel's native element count.
    
    Due to a get operation's asynchronous nature, the result is not returned right away, but a future that can be used to wait on the operation and get its result is returned.
    
    Errors are typically indicated by an exception that is wrapped in an ExecutionException that is thrown by the future. Only a destroyed channel will result in an immediate exception thrown by this method.
    
    Specified by:
    
    getControlsString in interface ChannelAccessChannel
    
    Returns:
    listenable future that can be used to retrieve the result of the operation and to be notified when the operation finishes.
  - getControlsString
```
public ListenableFuture<ChannelAccessAlarmOnlyString> getControlsString(int count)
```
    Description copied from interface: ChannelAccessChannel
    
    Gets the current value from the channel using the DBR_CTRL_STRING and the specified element count}.
    
    Due to a get operation's asynchronous nature, the result is not returned right away, but a future that can be used to wait on the operation and get its result is returned.
    
    Errors are typically indicated by an exception that is wrapped in an ExecutionException that is thrown by the future. Only errors in the parameters to this method or a destroyed channel will result in an immediate exception thrown by this method.
    
    Specified by:
    
    getControlsString in interface ChannelAccessChannel
    
    Parameters:
    count - number of elements to request from the server. Must be positive or zero. A value of zero is interpreted as the channel's native element count. If the specified number exceeds the channel's native element count, the get operation only returns the number of elements that is equal to the channel's native element count.
    
    Returns:
    listenable future that can be used to retrieve the result of the operation and to be notified when the operation finishes.
  - getShort
```
public ListenableFuture<ChannelAccessSimpleOnlyShort> getShort()
```
    Description copied from interface: ChannelAccessChannel
    
    Gets the current value from the channel using the DBR_SHORT data type and the channel's native element count.
    
    Due to a get operation's asynchronous nature, the result is not returned right away, but a future that can be used to wait on the operation and get its result is returned.
    
    Errors are typically indicated by an exception that is wrapped in an ExecutionException that is thrown by the future. Only a destroyed channel will result in an immediate exception thrown by this method.
    
    Specified by:
    
    getShort in interface ChannelAccessChannel
    
    Returns:
    listenable future that can be used to retrieve the result of the operation and to be notified when the operation finishes.
  - getShort
```
public ListenableFuture<ChannelAccessSimpleOnlyShort> getShort(int count)
```
    Description copied from interface: ChannelAccessChannel
    
    Gets the current value from the channel using the DBR_SHORT and the specified element count}.
    
    Due to a get operation's asynchronous nature, the result is not returned right away, but a future that can be used to wait on the operation and get its result is returned.
    
    Errors are typically indicated by an exception that is wrapped in an ExecutionException that is thrown by the future. Only errors in the parameters to this method or a destroyed channel will result in an immediate exception thrown by this method.
    
    Specified by:
    
    getShort in interface ChannelAccessChannel
    
    Parameters:
    count - number of elements to request from the server. Must be positive or zero. A value of zero is interpreted as the channel's native element count. If the specified number exceeds the channel's native element count, the get operation only returns the number of elements that is equal to the channel's native element count.
    
    Returns:
    listenable future that can be used to retrieve the result of the operation and to be notified when the operation finishes.
  - getAlarmShort
```
public ListenableFuture<ChannelAccessAlarmOnlyShort> getAlarmShort()
```
    Description copied from interface: ChannelAccessChannel
    
    Gets the current value from the channel using the DBR_STS_SHORT data type and the channel's native element count.
    
    Due to a get operation's asynchronous nature, the result is not returned right away, but a future that can be used to wait on the operation and get its result is returned.
    
    Errors are typically indicated by an exception that is wrapped in an ExecutionException that is thrown by the future. Only a destroyed channel will result in an immediate exception thrown by this method.
    
    Specified by:
    
    getAlarmShort in interface ChannelAccessChannel
    
    Returns:
    listenable future that can be used to retrieve the result of the operation and to be notified when the operation finishes.
  - getAlarmShort
```
public ListenableFuture<ChannelAccessAlarmOnlyShort> getAlarmShort(int count)
```
    Description copied from interface: ChannelAccessChannel
    
    Gets the current value from the channel using the DBR_STS_SHORT and the specified element count}.
    
    Due to a get operation's asynchronous nature, the result is not returned right away, but a future that can be used to wait on the operation and get its result is returned.
    
    Errors are typically indicated by an exception that is wrapped in an ExecutionException that is thrown by the future. Only errors in the parameters to this method or a destroyed channel will result in an immediate exception thrown by this method.
    
    Specified by:
    
    getAlarmShort in interface ChannelAccessChannel
    
    Parameters:
    count - number of elements to request from the server. Must be positive or zero. A value of zero is interpreted as the channel's native element count. If the specified number exceeds the channel's native element count, the get operation only returns the number of elements that is equal to the channel's native element count.
    
    Returns:
    listenable future that can be used to retrieve the result of the operation and to be notified when the operation finishes.
  - getTimeShort
```
public ListenableFuture<ChannelAccessTimeShort> getTimeShort()
```
    Description copied from interface: ChannelAccessChannel
    
    Gets the current value from the channel using the DBR_TIME_SHORT data type and the channel's native element count.
    
    Due to a get operation's asynchronous nature, the result is not returned right away, but a future that can be used to wait on the operation and get its result is returned.
    
    Errors are typically indicated by an exception that is wrapped in an ExecutionException that is thrown by the future. Only a destroyed channel will result in an immediate exception thrown by this method.
    
    Specified by:
    
    getTimeShort in interface ChannelAccessChannel
    
    Returns:
    listenable future that can be used to retrieve the result of the operation and to be notified when the operation finishes.
  - getTimeShort
```
public ListenableFuture<ChannelAccessTimeShort> getTimeShort(int count)
```
    Description copied from interface: ChannelAccessChannel
    
    Gets the current value from the channel using the DBR_TIME_SHORT and the specified element count}.
    
    Due to a get operation's asynchronous nature, the result is not returned right away, but a future that can be used to wait on the operation and get its result is returned.
    
    Errors are typically indicated by an exception that is wrapped in an ExecutionException that is thrown by the future. Only errors in the parameters to this method or a destroyed channel will result in an immediate exception thrown by this method.
    
    Specified by:
    
    getTimeShort in interface ChannelAccessChannel
    
    Parameters:
    count - number of elements to request from the server. Must be positive or zero. A value of zero is interpreted as the channel's native element count. If the specified number exceeds the channel's native element count, the get operation only returns the number of elements that is equal to the channel's native element count.
    
    Returns:
    listenable future that can be used to retrieve the result of the operation and to be notified when the operation finishes.
  - getGraphicsShort
```
public ListenableFuture<ChannelAccessGraphicsOnlyShort> getGraphicsShort()
```
    Description copied from interface: ChannelAccessChannel
    
    Gets the current value from the channel using the DBR_GR_SHORT data type and the channel's native element count.
    
    Due to a get operation's asynchronous nature, the result is not returned right away, but a future that can be used to wait on the operation and get its result is returned.
    
    Errors are typically indicated by an exception that is wrapped in an ExecutionException that is thrown by the future. Only a destroyed channel will result in an immediate exception thrown by this method.
    
    Specified by:
    
    getGraphicsShort in interface ChannelAccessChannel
    
    Returns:
    listenable future that can be used to retrieve the result of the operation and to be notified when the operation finishes.
  - getGraphicsShort
```
public ListenableFuture<ChannelAccessGraphicsOnlyShort> getGraphicsShort(int count)
```
    Description copied from interface: ChannelAccessChannel
    
    Gets the current value from the channel using the DBR_GR_SHORT and the specified element count}.
    
    Due to a get operation's asynchronous nature, the result is not returned right away, but a future that can be used to wait on the operation and get its result is returned.
    
    Errors are typically indicated by an exception that is wrapped in an ExecutionException that is thrown by the future. Only errors in the parameters to this method or a destroyed channel will result in an immediate exception thrown by this method.
    
    Specified by:
    
    getGraphicsShort in interface ChannelAccessChannel
    
    Parameters:
    count - number of elements to request from the server. Must be positive or zero. A value of zero is interpreted as the channel's native element count. If the specified number exceeds the channel's native element count, the get operation only returns the number of elements that is equal to the channel's native element count.
    
    Returns:
    listenable future that can be used to retrieve the result of the operation and to be notified when the operation finishes.
  - getControlsShort
```
public ListenableFuture<ChannelAccessControlsShort> getControlsShort()
```
    Description copied from interface: ChannelAccessChannel
    
    Gets the current value from the channel using the DBR_CTRL_SHORT data type and the channel's native element count.
    
    Due to a get operation's asynchronous nature, the result is not returned right away, but a future that can be used to wait on the operation and get its result is returned.
    
    Errors are typically indicated by an exception that is wrapped in an ExecutionException that is thrown by the future. Only a destroyed channel will result in an immediate exception thrown by this method.
    
    Specified by:
    
    getControlsShort in interface ChannelAccessChannel
    
    Returns:
    listenable future that can be used to retrieve the result of the operation and to be notified when the operation finishes.
  - getControlsShort
```
public ListenableFuture<ChannelAccessControlsShort> getControlsShort(int count)
```
    Description copied from interface: ChannelAccessChannel
    
    Gets the current value from the channel using the DBR_CTRL_SHORT and the specified element count}.
    
    Due to a get operation's asynchronous nature, the result is not returned right away, but a future that can be used to wait on the operation and get its result is returned.
    
    Errors are typically indicated by an exception that is wrapped in an ExecutionException that is thrown by the future. Only errors in the parameters to this method or a destroyed channel will result in an immediate exception thrown by this method.
    
    Specified by:
    
    getControlsShort in interface ChannelAccessChannel
    
    Parameters:
    count - number of elements to request from the server. Must be positive or zero. A value of zero is interpreted as the channel's native element count. If the specified number exceeds the channel's native element count, the get operation only returns the number of elements that is equal to the channel's native element count.
    
    Returns:
    listenable future that can be used to retrieve the result of the operation and to be notified when the operation finishes.
  - getFloat
```
public ListenableFuture<ChannelAccessSimpleOnlyFloat> getFloat()
```
    Description copied from interface: ChannelAccessChannel
    
    Gets the current value from the channel using the DBR_FLOAT data type and the channel's native element count.
    
    Due to a get operation's asynchronous nature, the result is not returned right away, but a future that can be used to wait on the operation and get its result is returned.
    
    Errors are typically indicated by an exception that is wrapped in an ExecutionException that is thrown by the future. Only a destroyed channel will result in an immediate exception thrown by this method.
    
    Specified by:
    
    getFloat in interface ChannelAccessChannel
    
    Returns:
    listenable future that can be used to retrieve the result of the operation and to be notified when the operation finishes.
  - getFloat
```
public ListenableFuture<ChannelAccessSimpleOnlyFloat> getFloat(int count)
```
    Description copied from interface: ChannelAccessChannel
    
    Gets the current value from the channel using the DBR_FLOAT and the specified element count}.
    
    Due to a get operation's asynchronous nature, the result is not returned right away, but a future that can be used to wait on the operation and get its result is returned.
    
    Errors are typically indicated by an exception that is wrapped in an ExecutionException that is thrown by the future. Only errors in the parameters to this method or a destroyed channel will result in an immediate exception thrown by this method.
    
    Specified by:
    
    getFloat in interface ChannelAccessChannel
    
    Parameters:
    count - number of elements to request from the server. Must be positive or zero. A value of zero is interpreted as the channel's native element count. If the specified number exceeds the channel's native element count, the get operation only returns the number of elements that is equal to the channel's native element count.
    
    Returns:
    listenable future that can be used to retrieve the result of the operation and to be notified when the operation finishes.
  - getAlarmFloat
```
public ListenableFuture<ChannelAccessAlarmOnlyFloat> getAlarmFloat()
```
    Description copied from interface: ChannelAccessChannel
    
    Gets the current value from the channel using the DBR_STS_FLOAT data type and the channel's native element count.
    
    Due to a get operation's asynchronous nature, the result is not returned right away, but a future that can be used to wait on the operation and get its result is returned.
    
    Errors are typically indicated by an exception that is wrapped in an ExecutionException that is thrown by the future. Only a destroyed channel will result in an immediate exception thrown by this method.
    
    Specified by:
    
    getAlarmFloat in interface ChannelAccessChannel
    
    Returns:
    listenable future that can be used to retrieve the result of the operation and to be notified when the operation finishes.
  - getAlarmFloat
```
public ListenableFuture<ChannelAccessAlarmOnlyFloat> getAlarmFloat(int count)
```
    Description copied from interface: ChannelAccessChannel
    
    Gets the current value from the channel using the DBR_STS_FLOAT and the specified element count}.
    
    Due to a get operation's asynchronous nature, the result is not returned right away, but a future that can be used to wait on the operation and get its result is returned.
    
    Errors are typically indicated by an exception that is wrapped in an ExecutionException that is thrown by the future. Only errors in the parameters to this method or a destroyed channel will result in an immediate exception thrown by this method.
    
    Specified by:
    
    getAlarmFloat in interface ChannelAccessChannel
    
    Parameters:
    count - number of elements to request from the server. Must be positive or zero. A value of zero is interpreted as the channel's native element count. If the specified number exceeds the channel's native element count, the get operation only returns the number of elements that is equal to the channel's native element count.
    
    Returns:
    listenable future that can be used to retrieve the result of the operation and to be notified when the operation finishes.
  - getTimeFloat
```
public ListenableFuture<ChannelAccessTimeFloat> getTimeFloat()
```
    Description copied from interface: ChannelAccessChannel
    
    Gets the current value from the channel using the DBR_TIME_FLOAT data type and the channel's native element count.
    
    Due to a get operation's asynchronous nature, the result is not returned right away, but a future that can be used to wait on the operation and get its result is returned.
    
    Errors are typically indicated by an exception that is wrapped in an ExecutionException that is thrown by the future. Only a destroyed channel will result in an immediate exception thrown by this method.
    
    Specified by:
    
    getTimeFloat in interface ChannelAccessChannel
    
    Returns:
    listenable future that can be used to retrieve the result of the operation and to be notified when the operation finishes.
  - getTimeFloat
```
public ListenableFuture<ChannelAccessTimeFloat> getTimeFloat(int count)
```
    Description copied from interface: ChannelAccessChannel
    
    Gets the current value from the channel using the DBR_TIME_FLOAT and the specified element count}.
    
    Due to a get operation's asynchronous nature, the result is not returned right away, but a future that can be used to wait on the operation and get its result is returned.
    
    Errors are typically indicated by an exception that is wrapped in an ExecutionException that is thrown by the future. Only errors in the parameters to this method or a destroyed channel will result in an immediate exception thrown by this method.
    
    Specified by:
    
    getTimeFloat in interface ChannelAccessChannel
    
    Parameters:
    count - number of elements to request from the server. Must be positive or zero. A value of zero is interpreted as the channel's native element count. If the specified number exceeds the channel's native element count, the get operation only returns the number of elements that is equal to the channel's native element count.
    
    Returns:
    listenable future that can be used to retrieve the result of the operation and to be notified when the operation finishes.
  - getGraphicsFloat
```
public ListenableFuture<ChannelAccessGraphicsOnlyFloat> getGraphicsFloat()
```
    Description copied from interface: ChannelAccessChannel
    
    Gets the current value from the channel using the DBR_GR_FLOAT data type and the channel's native element count.
    
    Due to a get operation's asynchronous nature, the result is not returned right away, but a future that can be used to wait on the operation and get its result is returned.
    
    Errors are typically indicated by an exception that is wrapped in an ExecutionException that is thrown by the future. Only a destroyed channel will result in an immediate exception thrown by this method.
    
    Specified by:
    
    getGraphicsFloat in interface ChannelAccessChannel
    
    Returns:
    listenable future that can be used to retrieve the result of the operation and to be notified when the operation finishes.
  - getGraphicsFloat
```
public ListenableFuture<ChannelAccessGraphicsOnlyFloat> getGraphicsFloat(int count)
```
    Description copied from interface: ChannelAccessChannel
    
    Gets the current value from the channel using the DBR_GR_FLOAT and the specified element count}.
    
    Due to a get operation's asynchronous nature, the result is not returned right away, but a future that can be used to wait on the operation and get its result is returned.
    
    Errors are typically indicated by an exception that is wrapped in an ExecutionException that is thrown by the future. Only errors in the parameters to this method or a destroyed channel will result in an immediate exception thrown by this method.
    
    Specified by:
    
    getGraphicsFloat in interface ChannelAccessChannel
    
    Parameters:
    count - number of elements to request from the server. Must be positive or zero. A value of zero is interpreted as the channel's native element count. If the specified number exceeds the channel's native element count, the get operation only returns the number of elements that is equal to the channel's native element count.
    
    Returns:
    listenable future that can be used to retrieve the result of the operation and to be notified when the operation finishes.
  - getControlsFloat
```
public ListenableFuture<ChannelAccessControlsFloat> getControlsFloat()
```
    Description copied from interface: ChannelAccessChannel
    
    Gets the current value from the channel using the DBR_CTRL_FLOAT data type and the channel's native element count.
    
    Due to a get operation's asynchronous nature, the result is not returned right away, but a future that can be used to wait on the operation and get its result is returned.
    
    Errors are typically indicated by an exception that is wrapped in an ExecutionException that is thrown by the future. Only a destroyed channel will result in an immediate exception thrown by this method.
    
    Specified by:
    
    getControlsFloat in interface ChannelAccessChannel
    
    Returns:
    listenable future that can be used to retrieve the result of the operation and to be notified when the operation finishes.
  - getControlsFloat
```
public ListenableFuture<ChannelAccessControlsFloat> getControlsFloat(int count)
```
    Description copied from interface: ChannelAccessChannel
    
    Gets the current value from the channel using the DBR_CTRL_FLOAT and the specified element count}.
    
    Due to a get operation's asynchronous nature, the result is not returned right away, but a future that can be used to wait on the operation and get its result is returned.
    
    Errors are typically indicated by an exception that is wrapped in an ExecutionException that is thrown by the future. Only errors in the parameters to this method or a destroyed channel will result in an immediate exception thrown by this method.
    
    Specified by:
    
    getControlsFloat in interface ChannelAccessChannel
    
    Parameters:
    count - number of elements to request from the server. Must be positive or zero. A value of zero is interpreted as the channel's native element count. If the specified number exceeds the channel's native element count, the get operation only returns the number of elements that is equal to the channel's native element count.
    
    Returns:
    listenable future that can be used to retrieve the result of the operation and to be notified when the operation finishes.
  - getEnum
```
public ListenableFuture<ChannelAccessSimpleOnlyEnum> getEnum()
```
    Description copied from interface: ChannelAccessChannel
    
    Gets the current value from the channel using the DBR_ENUM data type and the channel's native element count.
    
    Due to a get operation's asynchronous nature, the result is not returned right away, but a future that can be used to wait on the operation and get its result is returned.
    
    Errors are typically indicated by an exception that is wrapped in an ExecutionException that is thrown by the future. Only a destroyed channel will result in an immediate exception thrown by this method.
    
    Specified by:
    
    getEnum in interface ChannelAccessChannel
    
    Returns:
    listenable future that can be used to retrieve the result of the operation and to be notified when the operation finishes.
  - getEnum
```
public ListenableFuture<ChannelAccessSimpleOnlyEnum> getEnum(int count)
```
    Description copied from interface: ChannelAccessChannel
    
    Gets the current value from the channel using the DBR_ENUM and the specified element count}.
    
    Due to a get operation's asynchronous nature, the result is not returned right away, but a future that can be used to wait on the operation and get its result is returned.
    
    Errors are typically indicated by an exception that is wrapped in an ExecutionException that is thrown by the future. Only errors in the parameters to this method or a destroyed channel will result in an immediate exception thrown by this method.
    
    Specified by:
    
    getEnum in interface ChannelAccessChannel
    
    Parameters:
    count - number of elements to request from the server. Must be positive or zero. A value of zero is interpreted as the channel's native element count. If the specified number exceeds the channel's native element count, the get operation only returns the number of elements that is equal to the channel's native element count.
    
    Returns:
    listenable future that can be used to retrieve the result of the operation and to be notified when the operation finishes.
  - getAlarmEnum
```
public ListenableFuture<ChannelAccessAlarmOnlyEnum> getAlarmEnum()
```
    Description copied from interface: ChannelAccessChannel
    
    Gets the current value from the channel using the DBR_STS_ENUM data type and the channel's native element count.
    
    Due to a get operation's asynchronous nature, the result is not returned right away, but a future that can be used to wait on the operation and get its result is returned.
    
    Errors are typically indicated by an exception that is wrapped in an ExecutionException that is thrown by the future. Only a destroyed channel will result in an immediate exception thrown by this method.
    
    Specified by:
    
    getAlarmEnum in interface ChannelAccessChannel
    
    Returns:
    listenable future that can be used to retrieve the result of the operation and to be notified when the operation finishes.
  - getAlarmEnum
```
public ListenableFuture<ChannelAccessAlarmOnlyEnum> getAlarmEnum(int count)
```
    Description copied from interface: ChannelAccessChannel
    
    Gets the current value from the channel using the DBR_STS_ENUM and the specified element count}.
    
    Due to a get operation's asynchronous nature, the result is not returned right away, but a future that can be used to wait on the operation and get its result is returned.
    
    Errors are typically indicated by an exception that is wrapped in an ExecutionException that is thrown by the future. Only errors in the parameters to this method or a destroyed channel will result in an immediate exception thrown by this method.
    
    Specified by:
    
    getAlarmEnum in interface ChannelAccessChannel
    
    Parameters:
    count - number of elements to request from the server. Must be positive or zero. A value of zero is interpreted as the channel's native element count. If the specified number exceeds the channel's native element count, the get operation only returns the number of elements that is equal to the channel's native element count.
    
    Returns:
    listenable future that can be used to retrieve the result of the operation and to be notified when the operation finishes.
  - getTimeEnum
```
public ListenableFuture<ChannelAccessTimeEnum> getTimeEnum()
```
    Description copied from interface: ChannelAccessChannel
    
    Gets the current value from the channel using the DBR_TIME_ENUM data type and the channel's native element count.
    
    Due to a get operation's asynchronous nature, the result is not returned right away, but a future that can be used to wait on the operation and get its result is returned.
    
    Errors are typically indicated by an exception that is wrapped in an ExecutionException that is thrown by the future. Only a destroyed channel will result in an immediate exception thrown by this method.
    
    Specified by:
    
    getTimeEnum in interface ChannelAccessChannel
    
    Returns:
    listenable future that can be used to retrieve the result of the operation and to be notified when the operation finishes.
  - getTimeEnum
```
public ListenableFuture<ChannelAccessTimeEnum> getTimeEnum(int count)
```
    Description copied from interface: ChannelAccessChannel
    
    Gets the current value from the channel using the DBR_TIME_ENUM and the specified element count}.
    
    Due to a get operation's asynchronous nature, the result is not returned right away, but a future that can be used to wait on the operation and get its result is returned.
    
    Errors are typically indicated by an exception that is wrapped in an ExecutionException that is thrown by the future. Only errors in the parameters to this method or a destroyed channel will result in an immediate exception thrown by this method.
    
    Specified by:
    
    getTimeEnum in interface ChannelAccessChannel
    
    Parameters:
    count - number of elements to request from the server. Must be positive or zero. A value of zero is interpreted as the channel's native element count. If the specified number exceeds the channel's native element count, the get operation only returns the number of elements that is equal to the channel's native element count.
    
    Returns:
    listenable future that can be used to retrieve the result of the operation and to be notified when the operation finishes.
  - getGraphicsEnum
```
public ListenableFuture<ChannelAccessGraphicsEnum> getGraphicsEnum()
```
    Description copied from interface: ChannelAccessChannel
    
    Gets the current value from the channel using the DBR_GR_ENUM data type and the channel's native element count.
    
    Due to a get operation's asynchronous nature, the result is not returned right away, but a future that can be used to wait on the operation and get its result is returned.
    
    Errors are typically indicated by an exception that is wrapped in an ExecutionException that is thrown by the future. Only a destroyed channel will result in an immediate exception thrown by this method.
    
    Specified by:
    
    getGraphicsEnum in interface ChannelAccessChannel
    
    Returns:
    listenable future that can be used to retrieve the result of the operation and to be notified when the operation finishes.
  - getGraphicsEnum
```
public ListenableFuture<ChannelAccessGraphicsEnum> getGraphicsEnum(int count)
```
    Description copied from interface: ChannelAccessChannel
    
    Gets the current value from the channel using the DBR_GR_ENUM and the specified element count}.
    
    Due to a get operation's asynchronous nature, the result is not returned right away, but a future that can be used to wait on the operation and get its result is returned.
    
    Errors are typically indicated by an exception that is wrapped in an ExecutionException that is thrown by the future. Only errors in the parameters to this method or a destroyed channel will result in an immediate exception thrown by this method.
    
    Specified by:
    
    getGraphicsEnum in interface ChannelAccessChannel
    
    Parameters:
    count - number of elements to request from the server. Must be positive or zero. A value of zero is interpreted as the channel's native element count. If the specified number exceeds the channel's native element count, the get operation only returns the number of elements that is equal to the channel's native element count.
    
    Returns:
    listenable future that can be used to retrieve the result of the operation and to be notified when the operation finishes.
  - getControlsEnum
```
public ListenableFuture<ChannelAccessGraphicsEnum> getControlsEnum()
```
    Description copied from interface: ChannelAccessChannel
    
    Gets the current value from the channel using the DBR_CTRL_ENUM data type and the channel's native element count.
    
    Due to a get operation's asynchronous nature, the result is not returned right away, but a future that can be used to wait on the operation and get its result is returned.
    
    Errors are typically indicated by an exception that is wrapped in an ExecutionException that is thrown by the future. Only a destroyed channel will result in an immediate exception thrown by this method.
    
    Specified by:
    
    getControlsEnum in interface ChannelAccessChannel
    
    Returns:
    listenable future that can be used to retrieve the result of the operation and to be notified when the operation finishes.
  - getControlsEnum
```
public ListenableFuture<ChannelAccessGraphicsEnum> getControlsEnum(int count)
```
    Description copied from interface: ChannelAccessChannel
    
    Gets the current value from the channel using the DBR_CTRL_ENUM and the specified element count}.
    
    Due to a get operation's asynchronous nature, the result is not returned right away, but a future that can be used to wait on the operation and get its result is returned.
    
    Errors are typically indicated by an exception that is wrapped in an ExecutionException that is thrown by the future. Only errors in the parameters to this method or a destroyed channel will result in an immediate exception thrown by this method.
    
    Specified by:
    
    getControlsEnum in interface ChannelAccessChannel
    
    Parameters:
    count - number of elements to request from the server. Must be positive or zero. A value of zero is interpreted as the channel's native element count. If the specified number exceeds the channel's native element count, the get operation only returns the number of elements that is equal to the channel's native element count.
    
    Returns:
    listenable future that can be used to retrieve the result of the operation and to be notified when the operation finishes.
  - getChar
```
public ListenableFuture<ChannelAccessSimpleOnlyChar> getChar()
```
    Description copied from interface: ChannelAccessChannel
    
    Gets the current value from the channel using the DBR_CHAR data type and the channel's native element count.
    
    Due to a get operation's asynchronous nature, the result is not returned right away, but a future that can be used to wait on the operation and get its result is returned.
    
    Errors are typically indicated by an exception that is wrapped in an ExecutionException that is thrown by the future. Only a destroyed channel will result in an immediate exception thrown by this method.
    
    Specified by:
    
    getChar in interface ChannelAccessChannel
    
    Returns:
    listenable future that can be used to retrieve the result of the operation and to be notified when the operation finishes.
  - getChar
```
public ListenableFuture<ChannelAccessSimpleOnlyChar> getChar(int count)
```
    Description copied from interface: ChannelAccessChannel
    
    Gets the current value from the channel using the DBR_CHAR and the specified element count}.
    
    Due to a get operation's asynchronous nature, the result is not returned right away, but a future that can be used to wait on the operation and get its result is returned.
    
    Errors are typically indicated by an exception that is wrapped in an ExecutionException that is thrown by the future. Only errors in the parameters to this method or a destroyed channel will result in an immediate exception thrown by this method.
    
    Specified by:
    
    getChar in interface ChannelAccessChannel
    
    Parameters:
    count - number of elements to request from the server. Must be positive or zero. A value of zero is interpreted as the channel's native element count. If the specified number exceeds the channel's native element count, the get operation only returns the number of elements that is equal to the channel's native element count.
    
    Returns:
    listenable future that can be used to retrieve the result of the operation and to be notified when the operation finishes.
  - getAlarmChar
```
public ListenableFuture<ChannelAccessAlarmOnlyChar> getAlarmChar()
```
    Description copied from interface: ChannelAccessChannel
    
    Gets the current value from the channel using the DBR_STS_CHAR data type and the channel's native element count.
    
    Due to a get operation's asynchronous nature, the result is not returned right away, but a future that can be used to wait on the operation and get its result is returned.
    
    Errors are typically indicated by an exception that is wrapped in an ExecutionException that is thrown by the future. Only a destroyed channel will result in an immediate exception thrown by this method.
    
    Specified by:
    
    getAlarmChar in interface ChannelAccessChannel
    
    Returns:
    listenable future that can be used to retrieve the result of the operation and to be notified when the operation finishes.
  - getAlarmChar
```
public ListenableFuture<ChannelAccessAlarmOnlyChar> getAlarmChar(int count)
```
    Description copied from interface: ChannelAccessChannel
    
    Gets the current value from the channel using the DBR_STS_CHAR and the specified element count}.
    
    Due to a get operation's asynchronous nature, the result is not returned right away, but a future that can be used to wait on the operation and get its result is returned.
    
    Errors are typically indicated by an exception that is wrapped in an ExecutionException that is thrown by the future. Only errors in the parameters to this method or a destroyed channel will result in an immediate exception thrown by this method.
    
    Specified by:
    
    getAlarmChar in interface ChannelAccessChannel
    
    Parameters:
    count - number of elements to request from the server. Must be positive or zero. A value of zero is interpreted as the channel's native element count. If the specified number exceeds the channel's native element count, the get operation only returns the number of elements that is equal to the channel's native element count.
    
    Returns:
    listenable future that can be used to retrieve the result of the operation and to be notified when the operation finishes.
  - getTimeChar
```
public ListenableFuture<ChannelAccessTimeChar> getTimeChar()
```
    Description copied from interface: ChannelAccessChannel
    
    Gets the current value from the channel using the DBR_TIME_CHAR data type and the channel's native element count.
    
    Due to a get operation's asynchronous nature, the result is not returned right away, but a future that can be used to wait on the operation and get its result is returned.
    
    Errors are typically indicated by an exception that is wrapped in an ExecutionException that is thrown by the future. Only a destroyed channel will result in an immediate exception thrown by this method.
    
    Specified by:
    
    getTimeChar in interface ChannelAccessChannel
    
    Returns:
    listenable future that can be used to retrieve the result of the operation and to be notified when the operation finishes.
  - getTimeChar
```
public ListenableFuture<ChannelAccessTimeChar> getTimeChar(int count)
```
    Description copied from interface: ChannelAccessChannel
    
    Gets the current value from the channel using the DBR_TIME_CHAR and the specified element count}.
    
    Due to a get operation's asynchronous nature, the result is not returned right away, but a future that can be used to wait on the operation and get its result is returned.
    
    Errors are typically indicated by an exception that is wrapped in an ExecutionException that is thrown by the future. Only errors in the parameters to this method or a destroyed channel will result in an immediate exception thrown by this method.
    
    Specified by:
    
    getTimeChar in interface ChannelAccessChannel
    
    Parameters:
    count - number of elements to request from the server. Must be positive or zero. A value of zero is interpreted as the channel's native element count. If the specified number exceeds the channel's native element count, the get operation only returns the number of elements that is equal to the channel's native element count.
    
    Returns:
    listenable future that can be used to retrieve the result of the operation and to be notified when the operation finishes.
  - getGraphicsChar
```
public ListenableFuture<ChannelAccessGraphicsOnlyChar> getGraphicsChar()
```
    Description copied from interface: ChannelAccessChannel
    
    Gets the current value from the channel using the DBR_GR_CHAR data type and the channel's native element count.
    
    Due to a get operation's asynchronous nature, the result is not returned right away, but a future that can be used to wait on the operation and get its result is returned.
    
    Errors are typically indicated by an exception that is wrapped in an ExecutionException that is thrown by the future. Only a destroyed channel will result in an immediate exception thrown by this method.
    
    Specified by:
    
    getGraphicsChar in interface ChannelAccessChannel
    
    Returns:
    listenable future that can be used to retrieve the result of the operation and to be notified when the operation finishes.
  - getGraphicsChar
```
public ListenableFuture<ChannelAccessGraphicsOnlyChar> getGraphicsChar(int count)
```
    Description copied from interface: ChannelAccessChannel
    
    Gets the current value from the channel using the DBR_GR_CHAR and the specified element count}.
    
    Due to a get operation's asynchronous nature, the result is not returned right away, but a future that can be used to wait on the operation and get its result is returned.
    
    Errors are typically indicated by an exception that is wrapped in an ExecutionException that is thrown by the future. Only errors in the parameters to this method or a destroyed channel will result in an immediate exception thrown by this method.
    
    Specified by:
    
    getGraphicsChar in interface ChannelAccessChannel
    
    Parameters:
    count - number of elements to request from the server. Must be positive or zero. A value of zero is interpreted as the channel's native element count. If the specified number exceeds the channel's native element count, the get operation only returns the number of elements that is equal to the channel's native element count.
    
    Returns:
    listenable future that can be used to retrieve the result of the operation and to be notified when the operation finishes.
  - getControlsChar
```
public ListenableFuture<ChannelAccessControlsChar> getControlsChar()
```
    Description copied from interface: ChannelAccessChannel
    
    Gets the current value from the channel using the DBR_CTRL_CHAR data type and the channel's native element count.
    
    Due to a get operation's asynchronous nature, the result is not returned right away, but a future that can be used to wait on the operation and get its result is returned.
    
    Errors are typically indicated by an exception that is wrapped in an ExecutionException that is thrown by the future. Only a destroyed channel will result in an immediate exception thrown by this method.
    
    Specified by:
    
    getControlsChar in interface ChannelAccessChannel
    
    Returns:
    listenable future that can be used to retrieve the result of the operation and to be notified when the operation finishes.
  - getControlsChar
```
public ListenableFuture<ChannelAccessControlsChar> getControlsChar(int count)
```
    Description copied from interface: ChannelAccessChannel
    
    Gets the current value from the channel using the DBR_CTRL_CHAR and the specified element count}.
    
    Due to a get operation's asynchronous nature, the result is not returned right away, but a future that can be used to wait on the operation and get its result is returned.
    
    Errors are typically indicated by an exception that is wrapped in an ExecutionException that is thrown by the future. Only errors in the parameters to this method or a destroyed channel will result in an immediate exception thrown by this method.
    
    Specified by:
    
    getControlsChar in interface ChannelAccessChannel
    
    Parameters:
    count - number of elements to request from the server. Must be positive or zero. A value of zero is interpreted as the channel's native element count. If the specified number exceeds the channel's native element count, the get operation only returns the number of elements that is equal to the channel's native element count.
    
    Returns:
    listenable future that can be used to retrieve the result of the operation and to be notified when the operation finishes.
  - getLong
```
public ListenableFuture<ChannelAccessSimpleOnlyLong> getLong()
```
    Description copied from interface: ChannelAccessChannel
    
    Gets the current value from the channel using the DBR_LONG data type and the channel's native element count.
    
    Due to a get operation's asynchronous nature, the result is not returned right away, but a future that can be used to wait on the operation and get its result is returned.
    
    Errors are typically indicated by an exception that is wrapped in an ExecutionException that is thrown by the future. Only a destroyed channel will result in an immediate exception thrown by this method.
    
    Specified by:
    
    getLong in interface ChannelAccessChannel
    
    Returns:
    listenable future that can be used to retrieve the result of the operation and to be notified when the operation finishes.
  - getLong
```
public ListenableFuture<ChannelAccessSimpleOnlyLong> getLong(int count)
```
    Description copied from interface: ChannelAccessChannel
    
    Gets the current value from the channel using the DBR_LONG and the specified element count}.
    
    Due to a get operation's asynchronous nature, the result is not returned right away, but a future that can be used to wait on the operation and get its result is returned.
    
    Errors are typically indicated by an exception that is wrapped in an ExecutionException that is thrown by the future. Only errors in the parameters to this method or a destroyed channel will result in an immediate exception thrown by this method.
    
    Specified by:
    
    getLong in interface ChannelAccessChannel
    
    Parameters:
    count - number of elements to request from the server. Must be positive or zero. A value of zero is interpreted as the channel's native element count. If the specified number exceeds the channel's native element count, the get operation only returns the number of elements that is equal to the channel's native element count.
    
    Returns:
    listenable future that can be used to retrieve the result of the operation and to be notified when the operation finishes.
  - getAlarmLong
```
public ListenableFuture<ChannelAccessAlarmOnlyLong> getAlarmLong()
```
    Description copied from interface: ChannelAccessChannel
    
    Gets the current value from the channel using the DBR_STS_LONG data type and the channel's native element count.
    
    Due to a get operation's asynchronous nature, the result is not returned right away, but a future that can be used to wait on the operation and get its result is returned.
    
    Errors are typically indicated by an exception that is wrapped in an ExecutionException that is thrown by the future. Only a destroyed channel will result in an immediate exception thrown by this method.
    
    Specified by:
    
    getAlarmLong in interface ChannelAccessChannel
    
    Returns:
    listenable future that can be used to retrieve the result of the operation and to be notified when the operation finishes.
  - getAlarmLong
```
public ListenableFuture<ChannelAccessAlarmOnlyLong> getAlarmLong(int count)
```
    Description copied from interface: ChannelAccessChannel
    
    Gets the current value from the channel using the DBR_STS_LONG and the specified element count}.
    
    Due to a get operation's asynchronous nature, the result is not returned right away, but a future that can be used to wait on the operation and get its result is returned.
    
    Errors are typically indicated by an exception that is wrapped in an ExecutionException that is thrown by the future. Only errors in the parameters to this method or a destroyed channel will result in an immediate exception thrown by this method.
    
    Specified by:
    
    getAlarmLong in interface ChannelAccessChannel
    
    Parameters:
    count - number of elements to request from the server. Must be positive or zero. A value of zero is interpreted as the channel's native element count. If the specified number exceeds the channel's native element count, the get operation only returns the number of elements that is equal to the channel's native element count.
    
    Returns:
    listenable future that can be used to retrieve the result of the operation and to be notified when the operation finishes.
  - getTimeLong
```
public ListenableFuture<ChannelAccessTimeLong> getTimeLong()
```
    Description copied from interface: ChannelAccessChannel
    
    Gets the current value from the channel using the DBR_TIME_LONG data type and the channel's native element count.
    
    Due to a get operation's asynchronous nature, the result is not returned right away, but a future that can be used to wait on the operation and get its result is returned.
    
    Errors are typically indicated by an exception that is wrapped in an ExecutionException that is thrown by the future. Only a destroyed channel will result in an immediate exception thrown by this method.
    
    Specified by:
    
    getTimeLong in interface ChannelAccessChannel
    
    Returns:
    listenable future that can be used to retrieve the result of the operation and to be notified when the operation finishes.
  - getTimeLong
```
public ListenableFuture<ChannelAccessTimeLong> getTimeLong(int count)
```
    Description copied from interface: ChannelAccessChannel
    
    Gets the current value from the channel using the DBR_TIME_LONG and the specified element count}.
    
    Due to a get operation's asynchronous nature, the result is not returned right away, but a future that can be used to wait on the operation and get its result is returned.
    
    Errors are typically indicated by an exception that is wrapped in an ExecutionException that is thrown by the future. Only errors in the parameters to this method or a destroyed channel will result in an immediate exception thrown by this method.
    
    Specified by:
    
    getTimeLong in interface ChannelAccessChannel
    
    Parameters:
    count - number of elements to request from the server. Must be positive or zero. A value of zero is interpreted as the channel's native element count. If the specified number exceeds the channel's native element count, the get operation only returns the number of elements that is equal to the channel's native element count.
    
    Returns:
    listenable future that can be used to retrieve the result of the operation and to be notified when the operation finishes.
  - getGraphicsLong
```
public ListenableFuture<ChannelAccessGraphicsOnlyLong> getGraphicsLong()
```
    Description copied from interface: ChannelAccessChannel
    
    Gets the current value from the channel using the DBR_GR_LONG data type and the channel's native element count.
    
    Due to a get operation's asynchronous nature, the result is not returned right away, but a future that can be used to wait on the operation and get its result is returned.
    
    Errors are typically indicated by an exception that is wrapped in an ExecutionException that is thrown by the future. Only a destroyed channel will result in an immediate exception thrown by this method.
    
    Specified by:
    
    getGraphicsLong in interface ChannelAccessChannel
    
    Returns:
    listenable future that can be used to retrieve the result of the operation and to be notified when the operation finishes.
  - getGraphicsLong
```
public ListenableFuture<ChannelAccessGraphicsOnlyLong> getGraphicsLong(int count)
```
    Description copied from interface: ChannelAccessChannel
    
    Gets the current value from the channel using the DBR_GR_LONG and the specified element count}.
    
    Due to a get operation's asynchronous nature, the result is not returned right away, but a future that can be used to wait on the operation and get its result is returned.
    
    Errors are typically indicated by an exception that is wrapped in an ExecutionException that is thrown by the future. Only errors in the parameters to this method or a destroyed channel will result in an immediate exception thrown by this method.
    
    Specified by:
    
    getGraphicsLong in interface ChannelAccessChannel
    
    Parameters:
    count - number of elements to request from the server. Must be positive or zero. A value of zero is interpreted as the channel's native element count. If the specified number exceeds the channel's native element count, the get operation only returns the number of elements that is equal to the channel's native element count.
    
    Returns:
    listenable future that can be used to retrieve the result of the operation and to be notified when the operation finishes.
  - getControlsLong
```
public ListenableFuture<ChannelAccessControlsLong> getControlsLong()
```
    Description copied from interface: ChannelAccessChannel
    
    Gets the current value from the channel using the DBR_CTRL_LONG data type and the channel's native element count.
    
    Due to a get operation's asynchronous nature, the result is not returned right away, but a future that can be used to wait on the operation and get its result is returned.
    
    Errors are typically indicated by an exception that is wrapped in an ExecutionException that is thrown by the future. Only a destroyed channel will result in an immediate exception thrown by this method.
    
    Specified by:
    
    getControlsLong in interface ChannelAccessChannel
    
    Returns:
    listenable future that can be used to retrieve the result of the operation and to be notified when the operation finishes.
  - getControlsLong
```
public ListenableFuture<ChannelAccessControlsLong> getControlsLong(int count)
```
    Description copied from interface: ChannelAccessChannel
    
    Gets the current value from the channel using the DBR_CTRL_LONG and the specified element count}.
    
    Due to a get operation's asynchronous nature, the result is not returned right away, but a future that can be used to wait on the operation and get its result is returned.
    
    Errors are typically indicated by an exception that is wrapped in an ExecutionException that is thrown by the future. Only errors in the parameters to this method or a destroyed channel will result in an immediate exception thrown by this method.
    
    Specified by:
    
    getControlsLong in interface ChannelAccessChannel
    
    Parameters:
    count - number of elements to request from the server. Must be positive or zero. A value of zero is interpreted as the channel's native element count. If the specified number exceeds the channel's native element count, the get operation only returns the number of elements that is equal to the channel's native element count.
    
    Returns:
    listenable future that can be used to retrieve the result of the operation and to be notified when the operation finishes.
  - getDouble
```
public ListenableFuture<ChannelAccessSimpleOnlyDouble> getDouble()
```
    Description copied from interface: ChannelAccessChannel
    
    Gets the current value from the channel using the DBR_DOUBLE data type and the channel's native element count.
    
    Due to a get operation's asynchronous nature, the result is not returned right away, but a future that can be used to wait on the operation and get its result is returned.
    
    Errors are typically indicated by an exception that is wrapped in an ExecutionException that is thrown by the future. Only a destroyed channel will result in an immediate exception thrown by this method.
    
    Specified by:
    
    getDouble in interface ChannelAccessChannel
    
    Returns:
    listenable future that can be used to retrieve the result of the operation and to be notified when the operation finishes.
  - getDouble
```
public ListenableFuture<ChannelAccessSimpleOnlyDouble> getDouble(int count)
```
    Description copied from interface: ChannelAccessChannel
    
    Gets the current value from the channel using the DBR_DOUBLE and the specified element count}.
    
    Due to a get operation's asynchronous nature, the result is not returned right away, but a future that can be used to wait on the operation and get its result is returned.
    
    Errors are typically indicated by an exception that is wrapped in an ExecutionException that is thrown by the future. Only errors in the parameters to this method or a destroyed channel will result in an immediate exception thrown by this method.
    
    Specified by:
    
    getDouble in interface ChannelAccessChannel
    
    Parameters:
    count - number of elements to request from the server. Must be positive or zero. A value of zero is interpreted as the channel's native element count. If the specified number exceeds the channel's native element count, the get operation only returns the number of elements that is equal to the channel's native element count.
    
    Returns:
    listenable future that can be used to retrieve the result of the operation and to be notified when the operation finishes.
  - getAlarmDouble
```
public ListenableFuture<ChannelAccessAlarmOnlyDouble> getAlarmDouble()
```
    Description copied from interface: ChannelAccessChannel
    
    Gets the current value from the channel using the DBR_STS_DOUBLE data type and the channel's native element count.
    
    Due to a get operation's asynchronous nature, the result is not returned right away, but a future that can be used to wait on the operation and get its result is returned.
    
    Errors are typically indicated by an exception that is wrapped in an ExecutionException that is thrown by the future. Only a destroyed channel will result in an immediate exception thrown by this method.
    
    Specified by:
    
    getAlarmDouble in interface ChannelAccessChannel
    
    Returns:
    listenable future that can be used to retrieve the result of the operation and to be notified when the operation finishes.
  - getAlarmDouble
```
public ListenableFuture<ChannelAccessAlarmOnlyDouble> getAlarmDouble(int count)
```
    Description copied from interface: ChannelAccessChannel
    
    Gets the current value from the channel using the DBR_STS_DOUBLE and the specified element count}.
    
    Due to a get operation's asynchronous nature, the result is not returned right away, but a future that can be used to wait on the operation and get its result is returned.
    
    Errors are typically indicated by an exception that is wrapped in an ExecutionException that is thrown by the future. Only errors in the parameters to this method or a destroyed channel will result in an immediate exception thrown by this method.
    
    Specified by:
    
    getAlarmDouble in interface ChannelAccessChannel
    
    Parameters:
    count - number of elements to request from the server. Must be positive or zero. A value of zero is interpreted as the channel's native element count. If the specified number exceeds the channel's native element count, the get operation only returns the number of elements that is equal to the channel's native element count.
    
    Returns:
    listenable future that can be used to retrieve the result of the operation and to be notified when the operation finishes.
  - getTimeDouble
```
public ListenableFuture<ChannelAccessTimeDouble> getTimeDouble()
```
    Description copied from interface: ChannelAccessChannel
    
    Gets the current value from the channel using the DBR_TIME_DOUBLE data type and the channel's native element count.
    
    Due to a get operation's asynchronous nature, the result is not returned right away, but a future that can be used to wait on the operation and get its result is returned.
    
    Errors are typically indicated by an exception that is wrapped in an ExecutionException that is thrown by the future. Only a destroyed channel will result in an immediate exception thrown by this method.
    
    Specified by:
    
    getTimeDouble in interface ChannelAccessChannel
    
    Returns:
    listenable future that can be used to retrieve the result of the operation and to be notified when the operation finishes.
  - getTimeDouble
```
public ListenableFuture<ChannelAccessTimeDouble> getTimeDouble(int count)
```
    Description copied from interface: ChannelAccessChannel
    
    Gets the current value from the channel using the DBR_TIME_DOUBLE and the specified element count}.
    
    Due to a get operation's asynchronous nature, the result is not returned right away, but a future that can be used to wait on the operation and get its result is returned.
    
    Errors are typically indicated by an exception that is wrapped in an ExecutionException that is thrown by the future. Only errors in the parameters to this method or a destroyed channel will result in an immediate exception thrown by this method.
    
    Specified by:
    
    getTimeDouble in interface ChannelAccessChannel
    
    Parameters:
    count - number of elements to request from the server. Must be positive or zero. A value of zero is interpreted as the channel's native element count. If the specified number exceeds the channel's native element count, the get operation only returns the number of elements that is equal to the channel's native element count.
    
    Returns:
    listenable future that can be used to retrieve the result of the operation and to be notified when the operation finishes.
  - getGraphicsDouble
```
public ListenableFuture<ChannelAccessGraphicsOnlyDouble> getGraphicsDouble()
```
    Description copied from interface: ChannelAccessChannel
    
    Gets the current value from the channel using the DBR_GR_DOUBLE data type and the channel's native element count.
    
    Due to a get operation's asynchronous nature, the result is not returned right away, but a future that can be used to wait on the operation and get its result is returned.
    
    Errors are typically indicated by an exception that is wrapped in an ExecutionException that is thrown by the future. Only a destroyed channel will result in an immediate exception thrown by this method.
    
    Specified by:
    
    getGraphicsDouble in interface ChannelAccessChannel
    
    Returns:
    listenable future that can be used to retrieve the result of the operation and to be notified when the operation finishes.
  - getGraphicsDouble
```
public ListenableFuture<ChannelAccessGraphicsOnlyDouble> getGraphicsDouble(int count)
```
    Description copied from interface: ChannelAccessChannel
    
    Gets the current value from the channel using the DBR_GR_DOUBLE and the specified element count}.
    
    Due to a get operation's asynchronous nature, the result is not returned right away, but a future that can be used to wait on the operation and get its result is returned.
    
    Errors are typically indicated by an exception that is wrapped in an ExecutionException that is thrown by the future. Only errors in the parameters to this method or a destroyed channel will result in an immediate exception thrown by this method.
    
    Specified by:
    
    getGraphicsDouble in interface ChannelAccessChannel
    
    Parameters:
    count - number of elements to request from the server. Must be positive or zero. A value of zero is interpreted as the channel's native element count. If the specified number exceeds the channel's native element count, the get operation only returns the number of elements that is equal to the channel's native element count.
    
    Returns:
    listenable future that can be used to retrieve the result of the operation and to be notified when the operation finishes.
  - getControlsDouble
```
public ListenableFuture<ChannelAccessControlsDouble> getControlsDouble()
```
    Description copied from interface: ChannelAccessChannel
    
    Gets the current value from the channel using the DBR_CTRL_DOUBLE data type and the channel's native element count.
    
    Due to a get operation's asynchronous nature, the result is not returned right away, but a future that can be used to wait on the operation and get its result is returned.
    
    Errors are typically indicated by an exception that is wrapped in an ExecutionException that is thrown by the future. Only a destroyed channel will result in an immediate exception thrown by this method.
    
    Specified by:
    
    getControlsDouble in interface ChannelAccessChannel
    
    Returns:
    listenable future that can be used to retrieve the result of the operation and to be notified when the operation finishes.
  - getControlsDouble
```
public ListenableFuture<ChannelAccessControlsDouble> getControlsDouble(int count)
```
    Description copied from interface: ChannelAccessChannel
    
    Gets the current value from the channel using the DBR_CTRL_DOUBLE and the specified element count}.
    
    Due to a get operation's asynchronous nature, the result is not returned right away, but a future that can be used to wait on the operation and get its result is returned.
    
    Errors are typically indicated by an exception that is wrapped in an ExecutionException that is thrown by the future. Only errors in the parameters to this method or a destroyed channel will result in an immediate exception thrown by this method.
    
    Specified by:
    
    getControlsDouble in interface ChannelAccessChannel
    
    Parameters:
    count - number of elements to request from the server. Must be positive or zero. A value of zero is interpreted as the channel's native element count. If the specified number exceeds the channel's native element count, the get operation only returns the number of elements that is equal to the channel's native element count.
    
    Returns:
    listenable future that can be used to retrieve the result of the operation and to be notified when the operation finishes.
  - getAlarmAcknowledgementStatus
```
public ListenableFuture<ChannelAccessAlarmAcknowledgementStatus> getAlarmAcknowledgementStatus()
```
    Description copied from interface: ChannelAccessChannel
    
    Gets the current value from the channel using the DBR_STSACK_STRING data type and the channel's native element count.
    
    Due to a get operation's asynchronous nature, the result is not returned right away, but a future that can be used to wait on the operation and get its result is returned.
    
    Errors are typically indicated by an exception that is wrapped in an ExecutionException that is thrown by the future. Only a destroyed channel will result in an immediate exception thrown by this method.
    
    Specified by:
    
    getAlarmAcknowledgementStatus in interface ChannelAccessChannel
    
    Returns:
    listenable future that can be used to retrieve the result of the operation and to be notified when the operation finishes.
  - getAlarmAcknowledgementStatus
```
public ListenableFuture<ChannelAccessAlarmAcknowledgementStatus> getAlarmAcknowledgementStatus(int count)
```
    Description copied from interface: ChannelAccessChannel
    
    Gets the current value from the channel using the DBR_STSACK_STRING and the specified element count}.
    
    Due to a get operation's asynchronous nature, the result is not returned right away, but a future that can be used to wait on the operation and get its result is returned.
    
    Errors are typically indicated by an exception that is wrapped in an ExecutionException that is thrown by the future. Only errors in the parameters to this method or a destroyed channel will result in an immediate exception thrown by this method.
    
    Specified by:
    
    getAlarmAcknowledgementStatus in interface ChannelAccessChannel
    
    Parameters:
    count - number of elements to request from the server. Must be positive or zero. A value of zero is interpreted as the channel's native element count. If the specified number exceeds the channel's native element count, the get operation only returns the number of elements that is equal to the channel's native element count.
    
    Returns:
    listenable future that can be used to retrieve the result of the operation and to be notified when the operation finishes.
  - getClassName
```
public ListenableFuture<ChannelAccessClassName> getClassName()
```
    Description copied from interface: ChannelAccessChannel
    
    Gets the current value from the channel using the DBR_CLASS_NAME data type and the channel's native element count.
    
    Due to a get operation's asynchronous nature, the result is not returned right away, but a future that can be used to wait on the operation and get its result is returned.
    
    Errors are typically indicated by an exception that is wrapped in an ExecutionException that is thrown by the future. Only a destroyed channel will result in an immediate exception thrown by this method.
    
    Specified by:
    
    getClassName in interface ChannelAccessChannel
    
    Returns:
    listenable future that can be used to retrieve the result of the operation and to be notified when the operation finishes.
  - getClassName
```
public ListenableFuture<ChannelAccessClassName> getClassName(int count)
```
    Description copied from interface: ChannelAccessChannel
    
    Gets the current value from the channel using the DBR_CLASS_NAME and the specified element count}.
    
    Due to a get operation's asynchronous nature, the result is not returned right away, but a future that can be used to wait on the operation and get its result is returned.
    
    Errors are typically indicated by an exception that is wrapped in an ExecutionException that is thrown by the future. Only errors in the parameters to this method or a destroyed channel will result in an immediate exception thrown by this method.
    
    Specified by:
    
    getClassName in interface ChannelAccessChannel
    
    Parameters:
    count - number of elements to request from the server. Must be positive or zero. A value of zero is interpreted as the channel's native element count. If the specified number exceeds the channel's native element count, the get operation only returns the number of elements that is equal to the channel's native element count.
    
    Returns:
    listenable future that can be used to retrieve the result of the operation and to be notified when the operation finishes.
  - monitor
```
public ChannelAccessMonitor<? extends ChannelAccessGettableValue<?>> monitor(ChannelAccessValueType valueType)
```
    Description copied from interface: ChannelAccessChannel
    
    Creates a monitor for this channel using the specified type, the channel's native element count, and the default event mask. As a channel's native element count might vary over time, the number of elements in the values of monitor events might vary accordingly.
    
    A monitor can be created for a channel that is currently disconnected (or has not yet been connected). However, the monitor will only post events when the channel is connected.
    
    Errors are typically indicated by calling the monitor listeners' monitorError(...) method. Only errors in the parameters to this method or a destroyed channel will result in an immediate exception thrown by this method.
    
    Specified by:
    
    monitor in interface ChannelAccessChannel
    
    Parameters:
    valueType - type of the value that shall be sent for monitor events. The specified type must be allowed for get operations ( ChannelAccessValueType.isGettable() must return true). If null, the channel's native data type is used.
    
    Returns:
    monitor for this channel using the default event mask. The type of the values supplied with monitor events can be expected to match the specified valueType.
  - monitor
```
public ChannelAccessMonitor<? extends ChannelAccessGettableValue<?>> monitor(ChannelAccessValueType valueType,
                                                                    ChannelAccessEventMask eventMask)
```
    Description copied from interface: ChannelAccessChannel
    
    Creates a monitor for this channel using the specified type, the channel's native element count, and the specified event mask. As a channel's native element count might vary over time, the number of elements in the values of monitor events might vary accordingly.
    
    A monitor can be created for a channel that is currently disconnected (or has not yet been connected). However, the monitor will only post events when the channel is connected.
    
    Errors are typically indicated by calling the monitor listeners' monitorError(...) method. Only errors in the parameters to this method or a destroyed channel will result in an immediate exception thrown by this method.
    
    Specified by:
    
    monitor in interface ChannelAccessChannel
    
    Parameters:
    valueType - type of the value that shall be sent for monitor events. The specified type must be allowed for get operations ( ChannelAccessValueType.isGettable() must return true). If null, the channel's native data type is used.
    eventMask - event mask to use for the monitor. The event mask specifies which events on the server will trigger a monitor event. If null, the default event mask is used.
    
    Returns:
    monitor for this channel using the specified event mask. The type of the values supplied with monitor events can be expected to match the specified valueType.
  - monitor
```
public ChannelAccessMonitor<? extends ChannelAccessGettableValue<?>> monitor(ChannelAccessValueType valueType,
                                                                    int count)
```
    Description copied from interface: ChannelAccessChannel
    
    Creates a monitor for this channel using the specified type, the specified element count, and the default event mask.
    
    A monitor can be created for a channel that is currently disconnected (or has not yet been connected). However, the monitor will only post events when the channel is connected.
    
    Errors are typically indicated by calling the monitor listeners' monitorError(...) method. Only errors in the parameters to this method or a destroyed channel will result in an immediate exception thrown by this method.
    
    Specified by:
    
    monitor in interface ChannelAccessChannel
    
    Parameters:
    valueType - type of the value that shall be sent for monitor events. The specified type must be allowed for get operations ( ChannelAccessValueType.isGettable() must return true). If null, the channel's native data type is used.
    count - number of elements to request from the server. Must be positive or zero. A value of zero is interpreted as the channel's native element count.
    
    Returns:
    monitor for this channel using the default event mask. The type of the values supplied with monitor events can be expected to match the specified valueType and the values can be expected to not exceed the specified number of elements.
  - monitorNative
```
public ChannelAccessMonitor<? extends ChannelAccessGettableValue<?>> monitorNative()
```
    Description copied from interface: ChannelAccessChannel
    
    Creates a monitor for this channel using the channel's native data type, the channel's native element count, and the default event mask. As a channel's native data type and native element count might vary over time, the type of the values and the number of elements in the values of monitor events might vary accordingly.
    
    A monitor can be created for a channel that is currently disconnected (or has not yet been connected). However, the monitor will only post events when the channel is connected.
    
    Errors are typically indicated by calling the monitor listeners' monitorError(...) method. Only a destroyed channel will result in an immediate exception thrown by this method.
    
    Specified by:
    
    monitorNative in interface ChannelAccessChannel
    
    Returns:
    monitor for this channel using the default event mask.
  - monitorNative
```
public ChannelAccessMonitor<? extends ChannelAccessGettableValue<?>> monitorNative(ChannelAccessEventMask eventMask)
```
    Description copied from interface: ChannelAccessChannel
    
    Creates a monitor for this channel using the channel's native data type, the channel's native element count, and the specified event mask. As a channel's native data type and native element count might vary over time, the type of the values and the number of elements in the values of monitor events might vary accordingly.
    
    A monitor can be created for a channel that is currently disconnected (or has not yet been connected). However, the monitor will only post events when the channel is connected.
    
    Errors are typically indicated by calling the monitor listeners' monitorError(...) method. Only a destroyed channel will result in an immediate exception thrown by this method.
    
    Specified by:
    
    monitorNative in interface ChannelAccessChannel
    
    Parameters:
    eventMask - event mask to use for the monitor. The event mask specifies which events on the server will trigger a monitor event. If null, the default event mask is used.
    
    Returns:
    monitor for this channel using the specified event mask.
  - monitorNative
```
public ChannelAccessMonitor<? extends ChannelAccessGettableValue<?>> monitorNative(int count)
```
    Description copied from interface: ChannelAccessChannel
    
    Creates a monitor for this channel using the channel's native data type, the specified element count, and the default event mask. As a channel's native data type might vary over time, the type of the values of monitor events might vary accordingly.
    
    A monitor can be created for a channel that is currently disconnected (or has not yet been connected). However, the monitor will only post events when the channel is connected.
    
    Errors are typically indicated by calling the monitor listeners' monitorError(...) method. Only errors in the parameters to this method or a destroyed channel will result in an immediate exception thrown by this method.
    
    Specified by:
    
    monitorNative in interface ChannelAccessChannel
    
    Parameters:
    count - number of elements to request from the server. Must be positive or zero. A value of zero is interpreted as the channel's native element count. If the specified number exceeds the channel's native element count, the monitor event will only provide the number of elements that is equal to the channel's native element count.
    
    Returns:
    monitor for this channel using the default event mask. The values supplied with monitor events can be expected to not exceed the specified number of elements.
  - monitorNative
```
public ChannelAccessMonitor<? extends ChannelAccessGettableValue<?>> monitorNative(int count,
                                                                          ChannelAccessEventMask eventMask)
```
    Description copied from interface: ChannelAccessChannel
    
    Creates a monitor for this channel using the channel's native data type, the specified element count, and the specified event mask. As a channel's native data type might vary over time, the type of the values of monitor events might vary accordingly.
    
    A monitor can be created for a channel that is currently disconnected (or has not yet been connected). However, the monitor will only post events when the channel is connected.
    
    Errors are typically indicated by calling the monitor listeners' monitorError(...) method. Only errors in the parameters to this method or a destroyed channel will result in an immediate exception thrown by this method.
    
    Specified by:
    
    monitorNative in interface ChannelAccessChannel
    
    Parameters:
    count - number of elements to request from the server. Must be positive or zero. A value of zero is interpreted as the channel's native element count. If the specified number exceeds the channel's native element count, the monitor event will only provide the number of elements that is equal to the channel's native element count.
    eventMask - event mask to use for the monitor. The event mask specifies which events on the server will trigger a monitor event. If null, the default event mask is used.
    
    Returns:
    monitor for this channel using the specified event mask. The values supplied with monitor events can be expected to not exceed the specified number of elements.
  - monitorString
```
public ChannelAccessMonitor<ChannelAccessSimpleOnlyString> monitorString()
```
    Description copied from interface: ChannelAccessChannel
    
    Creates a monitor for this channel using the DBR_STRING data type, the channel's native element count, and the default event mask. As a channel's native element count might vary over time, the number of elements in the values of monitor events might vary accordingly.
    
    A monitor can be created for a channel that is currently disconnected (or has not yet been connected). However, the monitor will only post events when the channel is connected.
    
    Errors are typically indicated by calling the monitor listeners' monitorError(...) method. Only a destroyed channel will result in an immediate exception thrown by this method.
    
    Specified by:
    
    monitorString in interface ChannelAccessChannel
    
    Returns:
    monitor for this channel using the default event mask.
  - monitorString
```
public ChannelAccessMonitor<ChannelAccessSimpleOnlyString> monitorString(ChannelAccessEventMask eventMask)
```
    Description copied from interface: ChannelAccessChannel
    
    Creates a monitor for this channel using the DBR_STRING data type, the channel's native element count, and the specified event mask. As a channel's native element count might vary over time, the number of elements in the values of monitor events might vary accordingly.
    
    A monitor can be created for a channel that is currently disconnected (or has not yet been connected). However, the monitor will only post events when the channel is connected.
    
    Errors are typically indicated by calling the monitor listeners' monitorError(...) method. Only a destroyed channel will result in an immediate exception thrown by this method.
    
    Specified by:
    
    monitorString in interface ChannelAccessChannel
    
    Parameters:
    eventMask - event mask to use for the monitor. The event mask specifies which events on the server will trigger a monitor event. If null, the default event mask is used.
    
    Returns:
    monitor for this channel using the specified event mask.
  - monitorString
```
public ChannelAccessMonitor<ChannelAccessSimpleOnlyString> monitorString(int count)
```
    Description copied from interface: ChannelAccessChannel
    
    Creates a monitor for this channel using the DBR_STRING data type, the specified element count, and the default event mask.
    
    A monitor can be created for a channel that is currently disconnected (or has not yet been connected). However, the monitor will only post events when the channel is connected.
    
    Errors are typically indicated by calling the monitor listeners' monitorError(...) method. Only errors in the parameters to this method or a destroyed channel will result in an immediate exception thrown by this method.
    
    Specified by:
    
    monitorString in interface ChannelAccessChannel
    
    Parameters:
    count - number of elements to request from the server. Must be positive or zero. A value of zero is interpreted as the channel's native element count. If the specified number exceeds the channel's native element count, the monitor event will only provide the number of elements that is equal to the channel's native element count.
    
    Returns:
    monitor for this channel using the default event mask. The values supplied with monitor events can be expected to not exceed the specified number of elements.
  - monitorString
```
public ChannelAccessMonitor<ChannelAccessSimpleOnlyString> monitorString(int count,
                                                                ChannelAccessEventMask eventMask)
```
    Description copied from interface: ChannelAccessChannel
    
    Creates a monitor for this channel using the DBR_STRING data type, the specified element count, and the specified event mask.
    
    A monitor can be created for a channel that is currently disconnected (or has not yet been connected). However, the monitor will only post events when the channel is connected.
    
    Errors are typically indicated by calling the monitor listeners' monitorError(...) method. Only errors in the parameters to this method or a destroyed channel will result in an immediate exception thrown by this method.
    
    Specified by:
    
    monitorString in interface ChannelAccessChannel
    
    Parameters:
    count - number of elements to request from the server. Must be positive or zero. A value of zero is interpreted as the channel's native element count. If the specified number exceeds the channel's native element count, the monitor event will only provide the number of elements that is equal to the channel's native element count.
    eventMask - event mask to use for the monitor. The event mask specifies which events on the server will trigger a monitor event. If null, the default event mask is used.
    
    Returns:
    monitor for this channel using the specified event mask. The values supplied with monitor events can be expected to not exceed the specified number of elements.
  - monitorAlarmString
```
public ChannelAccessMonitor<ChannelAccessAlarmOnlyString> monitorAlarmString()
```
    Description copied from interface: ChannelAccessChannel
    
    Creates a monitor for this channel using the DBR_STS_STRING data type, the channel's native element count, and the default event mask. As a channel's native element count might vary over time, the number of elements in the values of monitor events might vary accordingly.
    
    A monitor can be created for a channel that is currently disconnected (or has not yet been connected). However, the monitor will only post events when the channel is connected.
    
    Errors are typically indicated by calling the monitor listeners' monitorError(...) method. Only a destroyed channel will result in an immediate exception thrown by this method.
    
    Specified by:
    
    monitorAlarmString in interface ChannelAccessChannel
    
    Returns:
    monitor for this channel using the default event mask.
  - monitorAlarmString
```
public ChannelAccessMonitor<ChannelAccessAlarmOnlyString> monitorAlarmString(ChannelAccessEventMask eventMask)
```
    Description copied from interface: ChannelAccessChannel
    
    Creates a monitor for this channel using the DBR_STS_STRING data type, the channel's native element count, and the specified event mask. As a channel's native element count might vary over time, the number of elements in the values of monitor events might vary accordingly.
    
    A monitor can be created for a channel that is currently disconnected (or has not yet been connected). However, the monitor will only post events when the channel is connected.
    
    Errors are typically indicated by calling the monitor listeners' monitorError(...) method. Only a destroyed channel will result in an immediate exception thrown by this method.
    
    Specified by:
    
    monitorAlarmString in interface ChannelAccessChannel
    
    Parameters:
    eventMask - event mask to use for the monitor. The event mask specifies which events on the server will trigger a monitor event. If null, the default event mask is used.
    
    Returns:
    monitor for this channel using the specified event mask.
  - monitorAlarmString
```
public ChannelAccessMonitor<ChannelAccessAlarmOnlyString> monitorAlarmString(int count)
```
    Description copied from interface: ChannelAccessChannel
    
    Creates a monitor for this channel using the DBR_STS_STRING data type, the specified element count, and the default event mask.
    
    A monitor can be created for a channel that is currently disconnected (or has not yet been connected). However, the monitor will only post events when the channel is connected.
    
    Errors are typically indicated by calling the monitor listeners' monitorError(...) method. Only errors in the parameters to this method or a destroyed channel will result in an immediate exception thrown by this method.
    
    Specified by:
    
    monitorAlarmString in interface ChannelAccessChannel
    
    Parameters:
    count - number of elements to request from the server. Must be positive or zero. A value of zero is interpreted as the channel's native element count. If the specified number exceeds the channel's native element count, the monitor event will only provide the number of elements that is equal to the channel's native element count.
    
    Returns:
    monitor for this channel using the default event mask. The values supplied with monitor events can be expected to not exceed the specified number of elements.
  - monitorAlarmString
```
public ChannelAccessMonitor<ChannelAccessAlarmOnlyString> monitorAlarmString(int count,
                                                                    ChannelAccessEventMask eventMask)
```
    Description copied from interface: ChannelAccessChannel
    
    Creates a monitor for this channel using the DBR_STS_STRING data type, the specified element count, and the specified event mask.
    
    A monitor can be created for a channel that is currently disconnected (or has not yet been connected). However, the monitor will only post events when the channel is connected.
    
    Errors are typically indicated by calling the monitor listeners' monitorError(...) method. Only errors in the parameters to this method or a destroyed channel will result in an immediate exception thrown by this method.
    
    Specified by:
    
    monitorAlarmString in interface ChannelAccessChannel
    
    Parameters:
    count - number of elements to request from the server. Must be positive or zero. A value of zero is interpreted as the channel's native element count. If the specified number exceeds the channel's native element count, the monitor event will only provide the number of elements that is equal to the channel's native element count.
    eventMask - event mask to use for the monitor. The event mask specifies which events on the server will trigger a monitor event. If null, the default event mask is used.
    
    Returns:
    monitor for this channel using the specified event mask. The values supplied with monitor events can be expected to not exceed the specified number of elements.
  - monitorTimeString
```
public ChannelAccessMonitor<ChannelAccessTimeString> monitorTimeString()
```
    Description copied from interface: ChannelAccessChannel
    
    Creates a monitor for this channel using the DBR_TIME_STRING data type, the channel's native element count, and the default event mask. As a channel's native element count might vary over time, the number of elements in the values of monitor events might vary accordingly.
    
    A monitor can be created for a channel that is currently disconnected (or has not yet been connected). However, the monitor will only post events when the channel is connected.
    
    Errors are typically indicated by calling the monitor listeners' monitorError(...) method. Only a destroyed channel will result in an immediate exception thrown by this method.
    
    Specified by:
    
    monitorTimeString in interface ChannelAccessChannel
    
    Returns:
    monitor for this channel using the default event mask.
  - monitorTimeString
```
public ChannelAccessMonitor<ChannelAccessTimeString> monitorTimeString(ChannelAccessEventMask eventMask)
```
    Description copied from interface: ChannelAccessChannel
    
    Creates a monitor for this channel using the DBR_TIME_STRING data type, the channel's native element count, and the specified event mask. As a channel's native element count might vary over time, the number of elements in the values of monitor events might vary accordingly.
    
    A monitor can be created for a channel that is currently disconnected (or has not yet been connected). However, the monitor will only post events when the channel is connected.
    
    Errors are typically indicated by calling the monitor listeners' monitorError(...) method. Only a destroyed channel will result in an immediate exception thrown by this method.
    
    Specified by:
    
    monitorTimeString in interface ChannelAccessChannel
    
    Parameters:
    eventMask - event mask to use for the monitor. The event mask specifies which events on the server will trigger a monitor event. If null, the default event mask is used.
    
    Returns:
    monitor for this channel using the specified event mask.
  - monitorTimeString
```
public ChannelAccessMonitor<ChannelAccessTimeString> monitorTimeString(int count)
```
    Description copied from interface: ChannelAccessChannel
    
    Creates a monitor for this channel using the DBR_TIME_STRING data type, the specified element count, and the default event mask.
    
    A monitor can be created for a channel that is currently disconnected (or has not yet been connected). However, the monitor will only post events when the channel is connected.
    
    Errors are typically indicated by calling the monitor listeners' monitorError(...) method. Only errors in the parameters to this method or a destroyed channel will result in an immediate exception thrown by this method.
    
    Specified by:
    
    monitorTimeString in interface ChannelAccessChannel
    
    Parameters:
    count - number of elements to request from the server. Must be positive or zero. A value of zero is interpreted as the channel's native element count. If the specified number exceeds the channel's native element count, the monitor event will only provide the number of elements that is equal to the channel's native element count.
    
    Returns:
    monitor for this channel using the default event mask. The values supplied with monitor events can be expected to not exceed the specified number of elements.
  - monitorTimeString
```
public ChannelAccessMonitor<ChannelAccessTimeString> monitorTimeString(int count,
                                                              ChannelAccessEventMask eventMask)
```
    Description copied from interface: ChannelAccessChannel
    
    Creates a monitor for this channel using the DBR_TIME_STRING data type, the specified element count, and the specified event mask.
    
    A monitor can be created for a channel that is currently disconnected (or has not yet been connected). However, the monitor will only post events when the channel is connected.
    
    Errors are typically indicated by calling the monitor listeners' monitorError(...) method. Only errors in the parameters to this method or a destroyed channel will result in an immediate exception thrown by this method.
    
    Specified by:
    
    monitorTimeString in interface ChannelAccessChannel
    
    Parameters:
    count - number of elements to request from the server. Must be positive or zero. A value of zero is interpreted as the channel's native element count. If the specified number exceeds the channel's native element count, the monitor event will only provide the number of elements that is equal to the channel's native element count.
    eventMask - event mask to use for the monitor. The event mask specifies which events on the server will trigger a monitor event. If null, the default event mask is used.
    
    Returns:
    monitor for this channel using the specified event mask. The values supplied with monitor events can be expected to not exceed the specified number of elements.
  - monitorGraphicsString
```
public ChannelAccessMonitor<ChannelAccessAlarmOnlyString> monitorGraphicsString()
```
    Description copied from interface: ChannelAccessChannel
    
    Creates a monitor for this channel using the DBR_GR_STRING data type, the channel's native element count, and the default event mask. As a channel's native element count might vary over time, the number of elements in the values of monitor events might vary accordingly.
    
    A monitor can be created for a channel that is currently disconnected (or has not yet been connected). However, the monitor will only post events when the channel is connected.
    
    Errors are typically indicated by calling the monitor listeners' monitorError(...) method. Only a destroyed channel will result in an immediate exception thrown by this method.
    
    Specified by:
    
    monitorGraphicsString in interface ChannelAccessChannel
    
    Returns:
    monitor for this channel using the default event mask.
  - monitorGraphicsString
```
public ChannelAccessMonitor<ChannelAccessAlarmOnlyString> monitorGraphicsString(ChannelAccessEventMask eventMask)
```
    Description copied from interface: ChannelAccessChannel
    
    Creates a monitor for this channel using the DBR_GR_STRING data type, the channel's native element count, and the specified event mask. As a channel's native element count might vary over time, the number of elements in the values of monitor events might vary accordingly.
    
    A monitor can be created for a channel that is currently disconnected (or has not yet been connected). However, the monitor will only post events when the channel is connected.
    
    Errors are typically indicated by calling the monitor listeners' monitorError(...) method. Only a destroyed channel will result in an immediate exception thrown by this method.
    
    Specified by:
    
    monitorGraphicsString in interface ChannelAccessChannel
    
    Parameters:
    eventMask - event mask to use for the monitor. The event mask specifies which events on the server will trigger a monitor event. If null, the default event mask is used.
    
    Returns:
    monitor for this channel using the specified event mask.
  - monitorGraphicsString
```
public ChannelAccessMonitor<ChannelAccessAlarmOnlyString> monitorGraphicsString(int count)
```
    Description copied from interface: ChannelAccessChannel
    
    Creates a monitor for this channel using the DBR_GR_STRING data type, the specified element count, and the default event mask.
    
    A monitor can be created for a channel that is currently disconnected (or has not yet been connected). However, the monitor will only post events when the channel is connected.
    
    Errors are typically indicated by calling the monitor listeners' monitorError(...) method. Only errors in the parameters to this method or a destroyed channel will result in an immediate exception thrown by this method.
    
    Specified by:
    
    monitorGraphicsString in interface ChannelAccessChannel
    
    Parameters:
    count - number of elements to request from the server. Must be positive or zero. A value of zero is interpreted as the channel's native element count. If the specified number exceeds the channel's native element count, the monitor event will only provide the number of elements that is equal to the channel's native element count.
    
    Returns:
    monitor for this channel using the default event mask. The values supplied with monitor events can be expected to not exceed the specified number of elements.
  - monitorGraphicsString
```
public ChannelAccessMonitor<ChannelAccessAlarmOnlyString> monitorGraphicsString(int count,
                                                                       ChannelAccessEventMask eventMask)
```
    Description copied from interface: ChannelAccessChannel
    
    Creates a monitor for this channel using the DBR_GR_STRING data type, the specified element count, and the specified event mask.
    
    A monitor can be created for a channel that is currently disconnected (or has not yet been connected). However, the monitor will only post events when the channel is connected.
    
    Errors are typically indicated by calling the monitor listeners' monitorError(...) method. Only errors in the parameters to this method or a destroyed channel will result in an immediate exception thrown by this method.
    
    Specified by:
    
    monitorGraphicsString in interface ChannelAccessChannel
    
    Parameters:
    count - number of elements to request from the server. Must be positive or zero. A value of zero is interpreted as the channel's native element count. If the specified number exceeds the channel's native element count, the monitor event will only provide the number of elements that is equal to the channel's native element count.
    eventMask - event mask to use for the monitor. The event mask specifies which events on the server will trigger a monitor event. If null, the default event mask is used.
    
    Returns:
    monitor for this channel using the specified event mask. The values supplied with monitor events can be expected to not exceed the specified number of elements.
  - monitorControlsString
```
public ChannelAccessMonitor<ChannelAccessAlarmOnlyString> monitorControlsString()
```
    Description copied from interface: ChannelAccessChannel
    
    Creates a monitor for this channel using the DBR_CTRL_STRING data type, the channel's native element count, and the default event mask. As a channel's native element count might vary over time, the number of elements in the values of monitor events might vary accordingly.
    
    A monitor can be created for a channel that is currently disconnected (or has not yet been connected). However, the monitor will only post events when the channel is connected.
    
    Errors are typically indicated by calling the monitor listeners' monitorError(...) method. Only a destroyed channel will result in an immediate exception thrown by this method.
    
    Specified by:
    
    monitorControlsString in interface ChannelAccessChannel
    
    Returns:
    monitor for this channel using the default event mask.
  - monitorControlsString
```
public ChannelAccessMonitor<ChannelAccessAlarmOnlyString> monitorControlsString(ChannelAccessEventMask eventMask)
```
    Description copied from interface: ChannelAccessChannel
    
    Creates a monitor for this channel using the DBR_CTRL_STRING data type, the channel's native element count, and the specified event mask. As a channel's native element count might vary over time, the number of elements in the values of monitor events might vary accordingly.
    
    A monitor can be created for a channel that is currently disconnected (or has not yet been connected). However, the monitor will only post events when the channel is connected.
    
    Errors are typically indicated by calling the monitor listeners' monitorError(...) method. Only a destroyed channel will result in an immediate exception thrown by this method.
    
    Specified by:
    
    monitorControlsString in interface ChannelAccessChannel
    
    Parameters:
    eventMask - event mask to use for the monitor. The event mask specifies which events on the server will trigger a monitor event. If null, the default event mask is used.
    
    Returns:
    monitor for this channel using the specified event mask.
  - monitorControlsString
```
public ChannelAccessMonitor<ChannelAccessAlarmOnlyString> monitorControlsString(int count)
```
    Description copied from interface: ChannelAccessChannel
    
    Creates a monitor for this channel using the DBR_CTRL_STRING data type, the specified element count, and the default event mask.
    
    A monitor can be created for a channel that is currently disconnected (or has not yet been connected). However, the monitor will only post events when the channel is connected.
    
    Errors are typically indicated by calling the monitor listeners' monitorError(...) method. Only errors in the parameters to this method or a destroyed channel will result in an immediate exception thrown by this method.
    
    Specified by:
    
    monitorControlsString in interface ChannelAccessChannel
    
    Parameters:
    count - number of elements to request from the server. Must be positive or zero. A value of zero is interpreted as the channel's native element count. If the specified number exceeds the channel's native element count, the monitor event will only provide the number of elements that is equal to the channel's native element count.
    
    Returns:
    monitor for this channel using the default event mask. The values supplied with monitor events can be expected to not exceed the specified number of elements.
  - monitorControlsString
```
public ChannelAccessMonitor<ChannelAccessAlarmOnlyString> monitorControlsString(int count,
                                                                       ChannelAccessEventMask eventMask)
```
    Description copied from interface: ChannelAccessChannel
    
    Creates a monitor for this channel using the DBR_CTRL_STRING data type, the specified element count, and the specified event mask.
    
    A monitor can be created for a channel that is currently disconnected (or has not yet been connected). However, the monitor will only post events when the channel is connected.
    
    Errors are typically indicated by calling the monitor listeners' monitorError(...) method. Only errors in the parameters to this method or a destroyed channel will result in an immediate exception thrown by this method.
    
    Specified by:
    
    monitorControlsString in interface ChannelAccessChannel
    
    Parameters:
    count - number of elements to request from the server. Must be positive or zero. A value of zero is interpreted as the channel's native element count. If the specified number exceeds the channel's native element count, the monitor event will only provide the number of elements that is equal to the channel's native element count.
    eventMask - event mask to use for the monitor. The event mask specifies which events on the server will trigger a monitor event. If null, the default event mask is used.
    
    Returns:
    monitor for this channel using the specified event mask. The values supplied with monitor events can be expected to not exceed the specified number of elements.
  - monitorShort
```
public ChannelAccessMonitor<ChannelAccessSimpleOnlyShort> monitorShort()
```
    Description copied from interface: ChannelAccessChannel
    
    Creates a monitor for this channel using the DBR_SHORT data type, the channel's native element count, and the default event mask. As a channel's native element count might vary over time, the number of elements in the values of monitor events might vary accordingly.
    
    A monitor can be created for a channel that is currently disconnected (or has not yet been connected). However, the monitor will only post events when the channel is connected.
    
    Errors are typically indicated by calling the monitor listeners' monitorError(...) method. Only a destroyed channel will result in an immediate exception thrown by this method.
    
    Specified by:
    
    monitorShort in interface ChannelAccessChannel
    
    Returns:
    monitor for this channel using the default event mask.
  - monitorShort
```
public ChannelAccessMonitor<ChannelAccessSimpleOnlyShort> monitorShort(ChannelAccessEventMask eventMask)
```
    Description copied from interface: ChannelAccessChannel
    
    Creates a monitor for this channel using the DBR_SHORT data type, the channel's native element count, and the specified event mask. As a channel's native element count might vary over time, the number of elements in the values of monitor events might vary accordingly.
    
    A monitor can be created for a channel that is currently disconnected (or has not yet been connected). However, the monitor will only post events when the channel is connected.
    
    Errors are typically indicated by calling the monitor listeners' monitorError(...) method. Only a destroyed channel will result in an immediate exception thrown by this method.
    
    Specified by:
    
    monitorShort in interface ChannelAccessChannel
    
    Parameters:
    eventMask - event mask to use for the monitor. The event mask specifies which events on the server will trigger a monitor event. If null, the default event mask is used.
    
    Returns:
    monitor for this channel using the specified event mask.
  - monitorShort
```
public ChannelAccessMonitor<ChannelAccessSimpleOnlyShort> monitorShort(int count)
```
    Description copied from interface: ChannelAccessChannel
    
    Creates a monitor for this channel using the DBR_SHORT data type, the specified element count, and the default event mask.
    
    A monitor can be created for a channel that is currently disconnected (or has not yet been connected). However, the monitor will only post events when the channel is connected.
    
    Errors are typically indicated by calling the monitor listeners' monitorError(...) method. Only errors in the parameters to this method or a destroyed channel will result in an immediate exception thrown by this method.
    
    Specified by:
    
    monitorShort in interface ChannelAccessChannel
    
    Parameters:
    count - number of elements to request from the server. Must be positive or zero. A value of zero is interpreted as the channel's native element count. If the specified number exceeds the channel's native element count, the monitor event will only provide the number of elements that is equal to the channel's native element count.
    
    Returns:
    monitor for this channel using the default event mask. The values supplied with monitor events can be expected to not exceed the specified number of elements.
  - monitorShort
```
public ChannelAccessMonitor<ChannelAccessSimpleOnlyShort> monitorShort(int count,
                                                              ChannelAccessEventMask eventMask)
```
    Description copied from interface: ChannelAccessChannel
    
    Creates a monitor for this channel using the DBR_SHORT data type, the specified element count, and the specified event mask.
    
    A monitor can be created for a channel that is currently disconnected (or has not yet been connected). However, the monitor will only post events when the channel is connected.
    
    Errors are typically indicated by calling the monitor listeners' monitorError(...) method. Only errors in the parameters to this method or a destroyed channel will result in an immediate exception thrown by this method.
    
    Specified by:
    
    monitorShort in interface ChannelAccessChannel
    
    Parameters:
    count - number of elements to request from the server. Must be positive or zero. A value of zero is interpreted as the channel's native element count. If the specified number exceeds the channel's native element count, the monitor event will only provide the number of elements that is equal to the channel's native element count.
    eventMask - event mask to use for the monitor. The event mask specifies which events on the server will trigger a monitor event. If null, the default event mask is used.
    
    Returns:
    monitor for this channel using the specified event mask. The values supplied with monitor events can be expected to not exceed the specified number of elements.
  - monitorAlarmShort
```
public ChannelAccessMonitor<ChannelAccessAlarmOnlyShort> monitorAlarmShort()
```
    Description copied from interface: ChannelAccessChannel
    
    Creates a monitor for this channel using the DBR_STS_SHORT data type, the channel's native element count, and the default event mask. As a channel's native element count might vary over time, the number of elements in the values of monitor events might vary accordingly.
    
    A monitor can be created for a channel that is currently disconnected (or has not yet been connected). However, the monitor will only post events when the channel is connected.
    
    Errors are typically indicated by calling the monitor listeners' monitorError(...) method. Only a destroyed channel will result in an immediate exception thrown by this method.
    
    Specified by:
    
    monitorAlarmShort in interface ChannelAccessChannel
    
    Returns:
    monitor for this channel using the default event mask.
  - monitorAlarmShort
```
public ChannelAccessMonitor<ChannelAccessAlarmOnlyShort> monitorAlarmShort(ChannelAccessEventMask eventMask)
```
    Description copied from interface: ChannelAccessChannel
    
    Creates a monitor for this channel using the DBR_STS_SHORT data type, the channel's native element count, and the specified event mask. As a channel's native element count might vary over time, the number of elements in the values of monitor events might vary accordingly.
    
    A monitor can be created for a channel that is currently disconnected (or has not yet been connected). However, the monitor will only post events when the channel is connected.
    
    Errors are typically indicated by calling the monitor listeners' monitorError(...) method. Only a destroyed channel will result in an immediate exception thrown by this method.
    
    Specified by:
    
    monitorAlarmShort in interface ChannelAccessChannel
    
    Parameters:
    eventMask - event mask to use for the monitor. The event mask specifies which events on the server will trigger a monitor event. If null, the default event mask is used.
    
    Returns:
    monitor for this channel using the specified event mask.
  - monitorAlarmShort
```
public ChannelAccessMonitor<ChannelAccessAlarmOnlyShort> monitorAlarmShort(int count)
```
    Description copied from interface: ChannelAccessChannel
    
    Creates a monitor for this channel using the DBR_STS_SHORT data type, the specified element count, and the default event mask.
    
    A monitor can be created for a channel that is currently disconnected (or has not yet been connected). However, the monitor will only post events when the channel is connected.
    
    Errors are typically indicated by calling the monitor listeners' monitorError(...) method. Only errors in the parameters to this method or a destroyed channel will result in an immediate exception thrown by this method.
    
    Specified by:
    
    monitorAlarmShort in interface ChannelAccessChannel
    
    Parameters:
    count - number of elements to request from the server. Must be positive or zero. A value of zero is interpreted as the channel's native element count. If the specified number exceeds the channel's native element count, the monitor event will only provide the number of elements that is equal to the channel's native element count.
    
    Returns:
    monitor for this channel using the default event mask. The values supplied with monitor events can be expected to not exceed the specified number of elements.
  - monitorAlarmShort
```
public ChannelAccessMonitor<ChannelAccessAlarmOnlyShort> monitorAlarmShort(int count,
                                                                  ChannelAccessEventMask eventMask)
```
    Description copied from interface: ChannelAccessChannel
    
    Creates a monitor for this channel using the DBR_STS_SHORT data type, the specified element count, and the specified event mask.
    
    A monitor can be created for a channel that is currently disconnected (or has not yet been connected). However, the monitor will only post events when the channel is connected.
    
    Errors are typically indicated by calling the monitor listeners' monitorError(...) method. Only errors in the parameters to this method or a destroyed channel will result in an immediate exception thrown by this method.
    
    Specified by:
    
    monitorAlarmShort in interface ChannelAccessChannel
    
    Parameters:
    count - number of elements to request from the server. Must be positive or zero. A value of zero is interpreted as the channel's native element count. If the specified number exceeds the channel's native element count, the monitor event will only provide the number of elements that is equal to the channel's native element count.
    eventMask - event mask to use for the monitor. The event mask specifies which events on the server will trigger a monitor event. If null, the default event mask is used.
    
    Returns:
    monitor for this channel using the specified event mask. The values supplied with monitor events can be expected to not exceed the specified number of elements.
  - monitorTimeShort
```
public ChannelAccessMonitor<ChannelAccessTimeShort> monitorTimeShort()
```
    Description copied from interface: ChannelAccessChannel
    
    Creates a monitor for this channel using the DBR_TIME_SHORT data type, the channel's native element count, and the default event mask. As a channel's native element count might vary over time, the number of elements in the values of monitor events might vary accordingly.
    
    A monitor can be created for a channel that is currently disconnected (or has not yet been connected). However, the monitor will only post events when the channel is connected.
    
    Errors are typically indicated by calling the monitor listeners' monitorError(...) method. Only a destroyed channel will result in an immediate exception thrown by this method.
    
    Specified by:
    
    monitorTimeShort in interface ChannelAccessChannel
    
    Returns:
    monitor for this channel using the default event mask.
  - monitorTimeShort
```
public ChannelAccessMonitor<ChannelAccessTimeShort> monitorTimeShort(ChannelAccessEventMask eventMask)
```
    Description copied from interface: ChannelAccessChannel
    
    Creates a monitor for this channel using the DBR_TIME_SHORT data type, the channel's native element count, and the specified event mask. As a channel's native element count might vary over time, the number of elements in the values of monitor events might vary accordingly.
    
    A monitor can be created for a channel that is currently disconnected (or has not yet been connected). However, the monitor will only post events when the channel is connected.
    
    Errors are typically indicated by calling the monitor listeners' monitorError(...) method. Only a destroyed channel will result in an immediate exception thrown by this method.
    
    Specified by:
    
    monitorTimeShort in interface ChannelAccessChannel
    
    Parameters:
    eventMask - event mask to use for the monitor. The event mask specifies which events on the server will trigger a monitor event. If null, the default event mask is used.
    
    Returns:
    monitor for this channel using the specified event mask.
  - monitorTimeShort
```
public ChannelAccessMonitor<ChannelAccessTimeShort> monitorTimeShort(int count)
```
    Description copied from interface: ChannelAccessChannel
    
    Creates a monitor for this channel using the DBR_TIME_SHORT data type, the specified element count, and the default event mask.
    
    A monitor can be created for a channel that is currently disconnected (or has not yet been connected). However, the monitor will only post events when the channel is connected.
    
    Errors are typically indicated by calling the monitor listeners' monitorError(...) method. Only errors in the parameters to this method or a destroyed channel will result in an immediate exception thrown by this method.
    
    Specified by:
    
    monitorTimeShort in interface ChannelAccessChannel
    
    Parameters:
    count - number of elements to request from the server. Must be positive or zero. A value of zero is interpreted as the channel's native element count. If the specified number exceeds the channel's native element count, the monitor event will only provide the number of elements that is equal to the channel's native element count.
    
    Returns:
    monitor for this channel using the default event mask. The values supplied with monitor events can be expected to not exceed the specified number of elements.
  - monitorTimeShort
```
public ChannelAccessMonitor<ChannelAccessTimeShort> monitorTimeShort(int count,
                                                            ChannelAccessEventMask eventMask)
```
    Description copied from interface: ChannelAccessChannel
    
    Creates a monitor for this channel using the DBR_TIME_SHORT data type, the specified element count, and the specified event mask.
    
    A monitor can be created for a channel that is currently disconnected (or has not yet been connected). However, the monitor will only post events when the channel is connected.
    
    Errors are typically indicated by calling the monitor listeners' monitorError(...) method. Only errors in the parameters to this method or a destroyed channel will result in an immediate exception thrown by this method.
    
    Specified by:
    
    monitorTimeShort in interface ChannelAccessChannel
    
    Parameters:
    count - number of elements to request from the server. Must be positive or zero. A value of zero is interpreted as the channel's native element count. If the specified number exceeds the channel's native element count, the monitor event will only provide the number of elements that is equal to the channel's native element count.
    eventMask - event mask to use for the monitor. The event mask specifies which events on the server will trigger a monitor event. If null, the default event mask is used.
    
    Returns:
    monitor for this channel using the specified event mask. The values supplied with monitor events can be expected to not exceed the specified number of elements.
  - monitorGraphicsShort
```
public ChannelAccessMonitor<ChannelAccessGraphicsOnlyShort> monitorGraphicsShort()
```
    Description copied from interface: ChannelAccessChannel
    
    Creates a monitor for this channel using the DBR_GR_SHORT data type, the channel's native element count, and the default event mask. As a channel's native element count might vary over time, the number of elements in the values of monitor events might vary accordingly.
    
    A monitor can be created for a channel that is currently disconnected (or has not yet been connected). However, the monitor will only post events when the channel is connected.
    
    Errors are typically indicated by calling the monitor listeners' monitorError(...) method. Only a destroyed channel will result in an immediate exception thrown by this method.
    
    Specified by:
    
    monitorGraphicsShort in interface ChannelAccessChannel
    
    Returns:
    monitor for this channel using the default event mask.
  - monitorGraphicsShort
```
public ChannelAccessMonitor<ChannelAccessGraphicsOnlyShort> monitorGraphicsShort(ChannelAccessEventMask eventMask)
```
    Description copied from interface: ChannelAccessChannel
    
    Creates a monitor for this channel using the DBR_GR_SHORT data type, the channel's native element count, and the specified event mask. As a channel's native element count might vary over time, the number of elements in the values of monitor events might vary accordingly.
    
    A monitor can be created for a channel that is currently disconnected (or has not yet been connected). However, the monitor will only post events when the channel is connected.
    
    Errors are typically indicated by calling the monitor listeners' monitorError(...) method. Only a destroyed channel will result in an immediate exception thrown by this method.
    
    Specified by:
    
    monitorGraphicsShort in interface ChannelAccessChannel
    
    Parameters:
    eventMask - event mask to use for the monitor. The event mask specifies which events on the server will trigger a monitor event. If null, the default event mask is used.
    
    Returns:
    monitor for this channel using the specified event mask.
  - monitorGraphicsShort
```
public ChannelAccessMonitor<ChannelAccessGraphicsOnlyShort> monitorGraphicsShort(int count)
```
    Description copied from interface: ChannelAccessChannel
    
    Creates a monitor for this channel using the DBR_GR_SHORT data type, the specified element count, and the default event mask.
    
    A monitor can be created for a channel that is currently disconnected (or has not yet been connected). However, the monitor will only post events when the channel is connected.
    
    Errors are typically indicated by calling the monitor listeners' monitorError(...) method. Only errors in the parameters to this method or a destroyed channel will result in an immediate exception thrown by this method.
    
    Specified by:
    
    monitorGraphicsShort in interface ChannelAccessChannel
    
    Parameters:
    count - number of elements to request from the server. Must be positive or zero. A value of zero is interpreted as the channel's native element count. If the specified number exceeds the channel's native element count, the monitor event will only provide the number of elements that is equal to the channel's native element count.
    
    Returns:
    monitor for this channel using the default event mask. The values supplied with monitor events can be expected to not exceed the specified number of elements.
  - monitorGraphicsShort
```
public ChannelAccessMonitor<ChannelAccessGraphicsOnlyShort> monitorGraphicsShort(int count,
                                                                        ChannelAccessEventMask eventMask)
```
    Description copied from interface: ChannelAccessChannel
    
    Creates a monitor for this channel using the DBR_GR_SHORT data type, the specified element count, and the specified event mask.
    
    A monitor can be created for a channel that is currently disconnected (or has not yet been connected). However, the monitor will only post events when the channel is connected.
    
    Errors are typically indicated by calling the monitor listeners' monitorError(...) method. Only errors in the parameters to this method or a destroyed channel will result in an immediate exception thrown by this method.
    
    Specified by:
    
    monitorGraphicsShort in interface ChannelAccessChannel
    
    Parameters:
    count - number of elements to request from the server. Must be positive or zero. A value of zero is interpreted as the channel's native element count. If the specified number exceeds the channel's native element count, the monitor event will only provide the number of elements that is equal to the channel's native element count.
    eventMask - event mask to use for the monitor. The event mask specifies which events on the server will trigger a monitor event. If null, the default event mask is used.
    
    Returns:
    monitor for this channel using the specified event mask. The values supplied with monitor events can be expected to not exceed the specified number of elements.
  - monitorControlsShort
```
public ChannelAccessMonitor<ChannelAccessControlsShort> monitorControlsShort()
```
    Description copied from interface: ChannelAccessChannel
    
    Creates a monitor for this channel using the DBR_CTRL_SHORT data type, the channel's native element count, and the default event mask. As a channel's native element count might vary over time, the number of elements in the values of monitor events might vary accordingly.
    
    A monitor can be created for a channel that is currently disconnected (or has not yet been connected). However, the monitor will only post events when the channel is connected.
    
    Errors are typically indicated by calling the monitor listeners' monitorError(...) method. Only a destroyed channel will result in an immediate exception thrown by this method.
    
    Specified by:
    
    monitorControlsShort in interface ChannelAccessChannel
    
    Returns:
    monitor for this channel using the default event mask.
  - monitorControlsShort
```
public ChannelAccessMonitor<ChannelAccessControlsShort> monitorControlsShort(ChannelAccessEventMask eventMask)
```
    Description copied from interface: ChannelAccessChannel
    
    Creates a monitor for this channel using the DBR_CTRL_SHORT data type, the channel's native element count, and the specified event mask. As a channel's native element count might vary over time, the number of elements in the values of monitor events might vary accordingly.
    
    A monitor can be created for a channel that is currently disconnected (or has not yet been connected). However, the monitor will only post events when the channel is connected.
    
    Errors are typically indicated by calling the monitor listeners' monitorError(...) method. Only a destroyed channel will result in an immediate exception thrown by this method.
    
    Specified by:
    
    monitorControlsShort in interface ChannelAccessChannel
    
    Parameters:
    eventMask - event mask to use for the monitor. The event mask specifies which events on the server will trigger a monitor event. If null, the default event mask is used.
    
    Returns:
    monitor for this channel using the specified event mask.
  - monitorControlsShort
```
public ChannelAccessMonitor<ChannelAccessControlsShort> monitorControlsShort(int count)
```
    Description copied from interface: ChannelAccessChannel
    
    Creates a monitor for this channel using the DBR_CTRL_SHORT data type, the specified element count, and the default event mask.
    
    A monitor can be created for a channel that is currently disconnected (or has not yet been connected). However, the monitor will only post events when the channel is connected.
    
    Errors are typically indicated by calling the monitor listeners' monitorError(...) method. Only errors in the parameters to this method or a destroyed channel will result in an immediate exception thrown by this method.
    
    Specified by:
    
    monitorControlsShort in interface ChannelAccessChannel
    
    Parameters:
    count - number of elements to request from the server. Must be positive or zero. A value of zero is interpreted as the channel's native element count. If the specified number exceeds the channel's native element count, the monitor event will only provide the number of elements that is equal to the channel's native element count.
    
    Returns:
    monitor for this channel using the default event mask. The values supplied with monitor events can be expected to not exceed the specified number of elements.
  - monitorControlsShort
```
public ChannelAccessMonitor<ChannelAccessControlsShort> monitorControlsShort(int count,
                                                                    ChannelAccessEventMask eventMask)
```
    Description copied from interface: ChannelAccessChannel
    
    Creates a monitor for this channel using the DBR_CTRL_SHORT data type, the specified element count, and the specified event mask.
    
    A monitor can be created for a channel that is currently disconnected (or has not yet been connected). However, the monitor will only post events when the channel is connected.
    
    Errors are typically indicated by calling the monitor listeners' monitorError(...) method. Only errors in the parameters to this method or a destroyed channel will result in an immediate exception thrown by this method.
    
    Specified by:
    
    monitorControlsShort in interface ChannelAccessChannel
    
    Parameters:
    count - number of elements to request from the server. Must be positive or zero. A value of zero is interpreted as the channel's native element count. If the specified number exceeds the channel's native element count, the monitor event will only provide the number of elements that is equal to the channel's native element count.
    eventMask - event mask to use for the monitor. The event mask specifies which events on the server will trigger a monitor event. If null, the default event mask is used.
    
    Returns:
    monitor for this channel using the specified event mask. The values supplied with monitor events can be expected to not exceed the specified number of elements.
  - monitorFloat
```
public ChannelAccessMonitor<ChannelAccessSimpleOnlyFloat> monitorFloat()
```
    Description copied from interface: ChannelAccessChannel
    
    Creates a monitor for this channel using the DBR_FLOAT data type, the channel's native element count, and the default event mask. As a channel's native element count might vary over time, the number of elements in the values of monitor events might vary accordingly.
    
    A monitor can be created for a channel that is currently disconnected (or has not yet been connected). However, the monitor will only post events when the channel is connected.
    
    Errors are typically indicated by calling the monitor listeners' monitorError(...) method. Only a destroyed channel will result in an immediate exception thrown by this method.
    
    Specified by:
    
    monitorFloat in interface ChannelAccessChannel
    
    Returns:
    monitor for this channel using the default event mask.
  - monitorFloat
```
public ChannelAccessMonitor<ChannelAccessSimpleOnlyFloat> monitorFloat(ChannelAccessEventMask eventMask)
```
    Description copied from interface: ChannelAccessChannel
    
    Creates a monitor for this channel using the DBR_FLOAT data type, the channel's native element count, and the specified event mask. As a channel's native element count might vary over time, the number of elements in the values of monitor events might vary accordingly.
    
    A monitor can be created for a channel that is currently disconnected (or has not yet been connected). However, the monitor will only post events when the channel is connected.
    
    Errors are typically indicated by calling the monitor listeners' monitorError(...) method. Only a destroyed channel will result in an immediate exception thrown by this method.
    
    Specified by:
    
    monitorFloat in interface ChannelAccessChannel
    
    Parameters:
    eventMask - event mask to use for the monitor. The event mask specifies which events on the server will trigger a monitor event. If null, the default event mask is used.
    
    Returns:
    monitor for this channel using the specified event mask.
  - monitorFloat
```
public ChannelAccessMonitor<ChannelAccessSimpleOnlyFloat> monitorFloat(int count)
```
    Description copied from interface: ChannelAccessChannel
    
    Creates a monitor for this channel using the DBR_FLOAT data type, the specified element count, and the default event mask.
    
    A monitor can be created for a channel that is currently disconnected (or has not yet been connected). However, the monitor will only post events when the channel is connected.
    
    Errors are typically indicated by calling the monitor listeners' monitorError(...) method. Only errors in the parameters to this method or a destroyed channel will result in an immediate exception thrown by this method.
    
    Specified by:
    
    monitorFloat in interface ChannelAccessChannel
    
    Parameters:
    count - number of elements to request from the server. Must be positive or zero. A value of zero is interpreted as the channel's native element count. If the specified number exceeds the channel's native element count, the monitor event will only provide the number of elements that is equal to the channel's native element count.
    
    Returns:
    monitor for this channel using the default event mask. The values supplied with monitor events can be expected to not exceed the specified number of elements.
  - monitorFloat
```
public ChannelAccessMonitor<ChannelAccessSimpleOnlyFloat> monitorFloat(int count,
                                                              ChannelAccessEventMask eventMask)
```
    Description copied from interface: ChannelAccessChannel
    
    Creates a monitor for this channel using the DBR_FLOAT data type, the specified element count, and the specified event mask.
    
    A monitor can be created for a channel that is currently disconnected (or has not yet been connected). However, the monitor will only post events when the channel is connected.
    
    Errors are typically indicated by calling the monitor listeners' monitorError(...) method. Only errors in the parameters to this method or a destroyed channel will result in an immediate exception thrown by this method.
    
    Specified by:
    
    monitorFloat in interface ChannelAccessChannel
    
    Parameters:
    count - number of elements to request from the server. Must be positive or zero. A value of zero is interpreted as the channel's native element count. If the specified number exceeds the channel's native element count, the monitor event will only provide the number of elements that is equal to the channel's native element count.
    eventMask - event mask to use for the monitor. The event mask specifies which events on the server will trigger a monitor event. If null, the default event mask is used.
    
    Returns:
    monitor for this channel using the specified event mask. The values supplied with monitor events can be expected to not exceed the specified number of elements.
  - monitorAlarmFloat
```
public ChannelAccessMonitor<ChannelAccessAlarmOnlyFloat> monitorAlarmFloat()
```
    Description copied from interface: ChannelAccessChannel
    
    Creates a monitor for this channel using the DBR_STS_FLOAT data type, the channel's native element count, and the default event mask. As a channel's native element count might vary over time, the number of elements in the values of monitor events might vary accordingly.
    
    A monitor can be created for a channel that is currently disconnected (or has not yet been connected). However, the monitor will only post events when the channel is connected.
    
    Errors are typically indicated by calling the monitor listeners' monitorError(...) method. Only a destroyed channel will result in an immediate exception thrown by this method.
    
    Specified by:
    
    monitorAlarmFloat in interface ChannelAccessChannel
    
    Returns:
    monitor for this channel using the default event mask.
  - monitorAlarmFloat
```
public ChannelAccessMonitor<ChannelAccessAlarmOnlyFloat> monitorAlarmFloat(ChannelAccessEventMask eventMask)
```
    Description copied from interface: ChannelAccessChannel
    
    Creates a monitor for this channel using the DBR_STS_FLOAT data type, the channel's native element count, and the specified event mask. As a channel's native element count might vary over time, the number of elements in the values of monitor events might vary accordingly.
    
    A monitor can be created for a channel that is currently disconnected (or has not yet been connected). However, the monitor will only post events when the channel is connected.
    
    Errors are typically indicated by calling the monitor listeners' monitorError(...) method. Only a destroyed channel will result in an immediate exception thrown by this method.
    
    Specified by:
    
    monitorAlarmFloat in interface ChannelAccessChannel
    
    Parameters:
    eventMask - event mask to use for the monitor. The event mask specifies which events on the server will trigger a monitor event. If null, the default event mask is used.
    
    Returns:
    monitor for this channel using the specified event mask.
  - monitorAlarmFloat
```
public ChannelAccessMonitor<ChannelAccessAlarmOnlyFloat> monitorAlarmFloat(int count)
```
    Description copied from interface: ChannelAccessChannel
    
    Creates a monitor for this channel using the DBR_STS_FLOAT data type, the specified element count, and the default event mask.
    
    A monitor can be created for a channel that is currently disconnected (or has not yet been connected). However, the monitor will only post events when the channel is connected.
    
    Errors are typically indicated by calling the monitor listeners' monitorError(...) method. Only errors in the parameters to this method or a destroyed channel will result in an immediate exception thrown by this method.
    
    Specified by:
    
    monitorAlarmFloat in interface ChannelAccessChannel
    
    Parameters:
    count - number of elements to request from the server. Must be positive or zero. A value of zero is interpreted as the channel's native element count. If the specified number exceeds the channel's native element count, the monitor event will only provide the number of elements that is equal to the channel's native element count.
    
    Returns:
    monitor for this channel using the default event mask. The values supplied with monitor events can be expected to not exceed the specified number of elements.
  - monitorAlarmFloat
```
public ChannelAccessMonitor<ChannelAccessAlarmOnlyFloat> monitorAlarmFloat(int count,
                                                                  ChannelAccessEventMask eventMask)
```
    Description copied from interface: ChannelAccessChannel
    
    Creates a monitor for this channel using the DBR_STS_FLOAT data type, the specified element count, and the specified event mask.
    
    A monitor can be created for a channel that is currently disconnected (or has not yet been connected). However, the monitor will only post events when the channel is connected.
    
    Errors are typically indicated by calling the monitor listeners' monitorError(...) method. Only errors in the parameters to this method or a destroyed channel will result in an immediate exception thrown by this method.
    
    Specified by:
    
    monitorAlarmFloat in interface ChannelAccessChannel
    
    Parameters:
    count - number of elements to request from the server. Must be positive or zero. A value of zero is interpreted as the channel's native element count. If the specified number exceeds the channel's native element count, the monitor event will only provide the number of elements that is equal to the channel's native element count.
    eventMask - event mask to use for the monitor. The event mask specifies which events on the server will trigger a monitor event. If null, the default event mask is used.
    
    Returns:
    monitor for this channel using the specified event mask. The values supplied with monitor events can be expected to not exceed the specified number of elements.
  - monitorTimeFloat
```
public ChannelAccessMonitor<ChannelAccessTimeFloat> monitorTimeFloat()
```
    Description copied from interface: ChannelAccessChannel
    
    Creates a monitor for this channel using the DBR_TIME_FLOAT data type, the channel's native element count, and the default event mask. As a channel's native element count might vary over time, the number of elements in the values of monitor events might vary accordingly.
    
    A monitor can be created for a channel that is currently disconnected (or has not yet been connected). However, the monitor will only post events when the channel is connected.
    
    Errors are typically indicated by calling the monitor listeners' monitorError(...) method. Only a destroyed channel will result in an immediate exception thrown by this method.
    
    Specified by:
    
    monitorTimeFloat in interface ChannelAccessChannel
    
    Returns:
    monitor for this channel using the default event mask.
  - monitorTimeFloat
```
public ChannelAccessMonitor<ChannelAccessTimeFloat> monitorTimeFloat(ChannelAccessEventMask eventMask)
```
    Description copied from interface: ChannelAccessChannel
    
    Creates a monitor for this channel using the DBR_TIME_FLOAT data type, the channel's native element count, and the specified event mask. As a channel's native element count might vary over time, the number of elements in the values of monitor events might vary accordingly.
    
    A monitor can be created for a channel that is currently disconnected (or has not yet been connected). However, the monitor will only post events when the channel is connected.
    
    Errors are typically indicated by calling the monitor listeners' monitorError(...) method. Only a destroyed channel will result in an immediate exception thrown by this method.
    
    Specified by:
    
    monitorTimeFloat in interface ChannelAccessChannel
    
    Parameters:
    eventMask - event mask to use for the monitor. The event mask specifies which events on the server will trigger a monitor event. If null, the default event mask is used.
    
    Returns:
    monitor for this channel using the specified event mask.
  - monitorTimeFloat
```
public ChannelAccessMonitor<ChannelAccessTimeFloat> monitorTimeFloat(int count)
```
    Description copied from interface: ChannelAccessChannel
    
    Creates a monitor for this channel using the DBR_TIME_FLOAT data type, the specified element count, and the default event mask.
    
    A monitor can be created for a channel that is currently disconnected (or has not yet been connected). However, the monitor will only post events when the channel is connected.
    
    Errors are typically indicated by calling the monitor listeners' monitorError(...) method. Only errors in the parameters to this method or a destroyed channel will result in an immediate exception thrown by this method.
    
    Specified by:
    
    monitorTimeFloat in interface ChannelAccessChannel
    
    Parameters:
    count - number of elements to request from the server. Must be positive or zero. A value of zero is interpreted as the channel's native element count. If the specified number exceeds the channel's native element count, the monitor event will only provide the number of elements that is equal to the channel's native element count.
    
    Returns:
    monitor for this channel using the default event mask. The values supplied with monitor events can be expected to not exceed the specified number of elements.
  - monitorTimeFloat
```
public ChannelAccessMonitor<ChannelAccessTimeFloat> monitorTimeFloat(int count,
                                                            ChannelAccessEventMask eventMask)
```
    Description copied from interface: ChannelAccessChannel
    
    Creates a monitor for this channel using the DBR_TIME_FLOAT data type, the specified element count, and the specified event mask.
    
    A monitor can be created for a channel that is currently disconnected (or has not yet been connected). However, the monitor will only post events when the channel is connected.
    
    Errors are typically indicated by calling the monitor listeners' monitorError(...) method. Only errors in the parameters to this method or a destroyed channel will result in an immediate exception thrown by this method.
    
    Specified by:
    
    monitorTimeFloat in interface ChannelAccessChannel
    
    Parameters:
    count - number of elements to request from the server. Must be positive or zero. A value of zero is interpreted as the channel's native element count. If the specified number exceeds the channel's native element count, the monitor event will only provide the number of elements that is equal to the channel's native element count.
    eventMask - event mask to use for the monitor. The event mask specifies which events on the server will trigger a monitor event. If null, the default event mask is used.
    
    Returns:
    monitor for this channel using the specified event mask. The values supplied with monitor events can be expected to not exceed the specified number of elements.
  - monitorGraphicsFloat
```
public ChannelAccessMonitor<ChannelAccessGraphicsOnlyFloat> monitorGraphicsFloat()
```
    Description copied from interface: ChannelAccessChannel
    
    Creates a monitor for this channel using the DBR_GR_FLOAT data type, the channel's native element count, and the default event mask. As a channel's native element count might vary over time, the number of elements in the values of monitor events might vary accordingly.
    
    A monitor can be created for a channel that is currently disconnected (or has not yet been connected). However, the monitor will only post events when the channel is connected.
    
    Errors are typically indicated by calling the monitor listeners' monitorError(...) method. Only a destroyed channel will result in an immediate exception thrown by this method.
    
    Specified by:
    
    monitorGraphicsFloat in interface ChannelAccessChannel
    
    Returns:
    monitor for this channel using the default event mask.
  - monitorGraphicsFloat
```
public ChannelAccessMonitor<ChannelAccessGraphicsOnlyFloat> monitorGraphicsFloat(ChannelAccessEventMask eventMask)
```
    Description copied from interface: ChannelAccessChannel
    
    Creates a monitor for this channel using the DBR_GR_FLOAT data type, the channel's native element count, and the specified event mask. As a channel's native element count might vary over time, the number of elements in the values of monitor events might vary accordingly.
    
    A monitor can be created for a channel that is currently disconnected (or has not yet been connected). However, the monitor will only post events when the channel is connected.
    
    Errors are typically indicated by calling the monitor listeners' monitorError(...) method. Only a destroyed channel will result in an immediate exception thrown by this method.
    
    Specified by:
    
    monitorGraphicsFloat in interface ChannelAccessChannel
    
    Parameters:
    eventMask - event mask to use for the monitor. The event mask specifies which events on the server will trigger a monitor event. If null, the default event mask is used.
    
    Returns:
    monitor for this channel using the specified event mask.
  - monitorGraphicsFloat
```
public ChannelAccessMonitor<ChannelAccessGraphicsOnlyFloat> monitorGraphicsFloat(int count)
```
    Description copied from interface: ChannelAccessChannel
    
    Creates a monitor for this channel using the DBR_GR_FLOAT data type, the specified element count, and the default event mask.
    
    A monitor can be created for a channel that is currently disconnected (or has not yet been connected). However, the monitor will only post events when the channel is connected.
    
    Errors are typically indicated by calling the monitor listeners' monitorError(...) method. Only errors in the parameters to this method or a destroyed channel will result in an immediate exception thrown by this method.
    
    Specified by:
    
    monitorGraphicsFloat in interface ChannelAccessChannel
    
    Parameters:
    count - number of elements to request from the server. Must be positive or zero. A value of zero is interpreted as the channel's native element count. If the specified number exceeds the channel's native element count, the monitor event will only provide the number of elements that is equal to the channel's native element count.
    
    Returns:
    monitor for this channel using the default event mask. The values supplied with monitor events can be expected to not exceed the specified number of elements.
  - monitorGraphicsFloat
```
public ChannelAccessMonitor<ChannelAccessGraphicsOnlyFloat> monitorGraphicsFloat(int count,
                                                                        ChannelAccessEventMask eventMask)
```
    Description copied from interface: ChannelAccessChannel
    
    Creates a monitor for this channel using the DBR_GR_FLOAT data type, the specified element count, and the specified event mask.
    
    A monitor can be created for a channel that is currently disconnected (or has not yet been connected). However, the monitor will only post events when the channel is connected.
    
    Errors are typically indicated by calling the monitor listeners' monitorError(...) method. Only errors in the parameters to this method or a destroyed channel will result in an immediate exception thrown by this method.
    
    Specified by:
    
    monitorGraphicsFloat in interface ChannelAccessChannel
    
    Parameters:
    count - number of elements to request from the server. Must be positive or zero. A value of zero is interpreted as the channel's native element count. If the specified number exceeds the channel's native element count, the monitor event will only provide the number of elements that is equal to the channel's native element count.
    eventMask - event mask to use for the monitor. The event mask specifies which events on the server will trigger a monitor event. If null, the default event mask is used.
    
    Returns:
    monitor for this channel using the specified event mask. The values supplied with monitor events can be expected to not exceed the specified number of elements.
  - monitorControlsFloat
```
public ChannelAccessMonitor<ChannelAccessControlsFloat> monitorControlsFloat()
```
    Description copied from interface: ChannelAccessChannel
    
    Creates a monitor for this channel using the DBR_CTRL_FLOAT data type, the channel's native element count, and the default event mask. As a channel's native element count might vary over time, the number of elements in the values of monitor events might vary accordingly.
    
    A monitor can be created for a channel that is currently disconnected (or has not yet been connected). However, the monitor will only post events when the channel is connected.
    
    Errors are typically indicated by calling the monitor listeners' monitorError(...) method. Only a destroyed channel will result in an immediate exception thrown by this method.
    
    Specified by:
    
    monitorControlsFloat in interface ChannelAccessChannel
    
    Returns:
    monitor for this channel using the default event mask.
  - monitorControlsFloat
```
public ChannelAccessMonitor<ChannelAccessControlsFloat> monitorControlsFloat(ChannelAccessEventMask eventMask)
```
    Description copied from interface: ChannelAccessChannel
    
    Creates a monitor for this channel using the DBR_CTRL_FLOAT data type, the channel's native element count, and the specified event mask. As a channel's native element count might vary over time, the number of elements in the values of monitor events might vary accordingly.
    
    A monitor can be created for a channel that is currently disconnected (or has not yet been connected). However, the monitor will only post events when the channel is connected.
    
    Errors are typically indicated by calling the monitor listeners' monitorError(...) method. Only a destroyed channel will result in an immediate exception thrown by this method.
    
    Specified by:
    
    monitorControlsFloat in interface ChannelAccessChannel
    
    Parameters:
    eventMask - event mask to use for the monitor. The event mask specifies which events on the server will trigger a monitor event. If null, the default event mask is used.
    
    Returns:
    monitor for this channel using the specified event mask.
  - monitorControlsFloat
```
public ChannelAccessMonitor<ChannelAccessControlsFloat> monitorControlsFloat(int count)
```
    Description copied from interface: ChannelAccessChannel
    
    Creates a monitor for this channel using the DBR_CTRL_FLOAT data type, the specified element count, and the default event mask.
    
    A monitor can be created for a channel that is currently disconnected (or has not yet been connected). However, the monitor will only post events when the channel is connected.
    
    Errors are typically indicated by calling the monitor listeners' monitorError(...) method. Only errors in the parameters to this method or a destroyed channel will result in an immediate exception thrown by this method.
    
    Specified by:
    
    monitorControlsFloat in interface ChannelAccessChannel
    
    Parameters:
    count - number of elements to request from the server. Must be positive or zero. A value of zero is interpreted as the channel's native element count. If the specified number exceeds the channel's native element count, the monitor event will only provide the number of elements that is equal to the channel's native element count.
    
    Returns:
    monitor for this channel using the default event mask. The values supplied with monitor events can be expected to not exceed the specified number of elements.
  - monitorControlsFloat
```
public ChannelAccessMonitor<ChannelAccessControlsFloat> monitorControlsFloat(int count,
                                                                    ChannelAccessEventMask eventMask)
```
    Description copied from interface: ChannelAccessChannel
    
    Creates a monitor for this channel using the DBR_CTRL_FLOAT data type, the specified element count, and the specified event mask.
    
    A monitor can be created for a channel that is currently disconnected (or has not yet been connected). However, the monitor will only post events when the channel is connected.
    
    Errors are typically indicated by calling the monitor listeners' monitorError(...) method. Only errors in the parameters to this method or a destroyed channel will result in an immediate exception thrown by this method.
    
    Specified by:
    
    monitorControlsFloat in interface ChannelAccessChannel
    
    Parameters:
    count - number of elements to request from the server. Must be positive or zero. A value of zero is interpreted as the channel's native element count. If the specified number exceeds the channel's native element count, the monitor event will only provide the number of elements that is equal to the channel's native element count.
    eventMask - event mask to use for the monitor. The event mask specifies which events on the server will trigger a monitor event. If null, the default event mask is used.
    
    Returns:
    monitor for this channel using the specified event mask. The values supplied with monitor events can be expected to not exceed the specified number of elements.
  - monitorEnum
```
public ChannelAccessMonitor<ChannelAccessSimpleOnlyEnum> monitorEnum()
```
    Description copied from interface: ChannelAccessChannel
    
    Creates a monitor for this channel using the DBR_ENUM data type, the channel's native element count, and the default event mask. As a channel's native element count might vary over time, the number of elements in the values of monitor events might vary accordingly.
    
    A monitor can be created for a channel that is currently disconnected (or has not yet been connected). However, the monitor will only post events when the channel is connected.
    
    Errors are typically indicated by calling the monitor listeners' monitorError(...) method. Only a destroyed channel will result in an immediate exception thrown by this method.
    
    Specified by:
    
    monitorEnum in interface ChannelAccessChannel
    
    Returns:
    monitor for this channel using the default event mask.
  - monitorEnum
```
public ChannelAccessMonitor<ChannelAccessSimpleOnlyEnum> monitorEnum(ChannelAccessEventMask eventMask)
```
    Description copied from interface: ChannelAccessChannel
    
    Creates a monitor for this channel using the DBR_ENUM data type, the channel's native element count, and the specified event mask. As a channel's native element count might vary over time, the number of elements in the values of monitor events might vary accordingly.
    
    A monitor can be created for a channel that is currently disconnected (or has not yet been connected). However, the monitor will only post events when the channel is connected.
    
    Errors are typically indicated by calling the monitor listeners' monitorError(...) method. Only a destroyed channel will result in an immediate exception thrown by this method.
    
    Specified by:
    
    monitorEnum in interface ChannelAccessChannel
    
    Parameters:
    eventMask - event mask to use for the monitor. The event mask specifies which events on the server will trigger a monitor event. If null, the default event mask is used.
    
    Returns:
    monitor for this channel using the specified event mask.
  - monitorEnum
```
public ChannelAccessMonitor<ChannelAccessSimpleOnlyEnum> monitorEnum(int count)
```
    Description copied from interface: ChannelAccessChannel
    
    Creates a monitor for this channel using the DBR_ENUM data type, the specified element count, and the default event mask.
    
    A monitor can be created for a channel that is currently disconnected (or has not yet been connected). However, the monitor will only post events when the channel is connected.
    
    Errors are typically indicated by calling the monitor listeners' monitorError(...) method. Only errors in the parameters to this method or a destroyed channel will result in an immediate exception thrown by this method.
    
    Specified by:
    
    monitorEnum in interface ChannelAccessChannel
    
    Parameters:
    count - number of elements to request from the server. Must be positive or zero. A value of zero is interpreted as the channel's native element count. If the specified number exceeds the channel's native element count, the monitor event will only provide the number of elements that is equal to the channel's native element count.
    
    Returns:
    monitor for this channel using the default event mask. The values supplied with monitor events can be expected to not exceed the specified number of elements.
  - monitorEnum
```
public ChannelAccessMonitor<ChannelAccessSimpleOnlyEnum> monitorEnum(int count,
                                                            ChannelAccessEventMask eventMask)
```
    Description copied from interface: ChannelAccessChannel
    
    Creates a monitor for this channel using the DBR_ENUM data type, the specified element count, and the specified event mask.
    
    A monitor can be created for a channel that is currently disconnected (or has not yet been connected). However, the monitor will only post events when the channel is connected.
    
    Errors are typically indicated by calling the monitor listeners' monitorError(...) method. Only errors in the parameters to this method or a destroyed channel will result in an immediate exception thrown by this method.
    
    Specified by:
    
    monitorEnum in interface ChannelAccessChannel
    
    Parameters:
    count - number of elements to request from the server. Must be positive or zero. A value of zero is interpreted as the channel's native element count. If the specified number exceeds the channel's native element count, the monitor event will only provide the number of elements that is equal to the channel's native element count.
    eventMask - event mask to use for the monitor. The event mask specifies which events on the server will trigger a monitor event. If null, the default event mask is used.
    
    Returns:
    monitor for this channel using the specified event mask. The values supplied with monitor events can be expected to not exceed the specified number of elements.
  - monitorAlarmEnum
```
public ChannelAccessMonitor<ChannelAccessAlarmOnlyEnum> monitorAlarmEnum()
```
    Description copied from interface: ChannelAccessChannel
    
    Creates a monitor for this channel using the DBR_STS_ENUM data type, the channel's native element count, and the default event mask. As a channel's native element count might vary over time, the number of elements in the values of monitor events might vary accordingly.
    
    A monitor can be created for a channel that is currently disconnected (or has not yet been connected). However, the monitor will only post events when the channel is connected.
    
    Errors are typically indicated by calling the monitor listeners' monitorError(...) method. Only a destroyed channel will result in an immediate exception thrown by this method.
    
    Specified by:
    
    monitorAlarmEnum in interface ChannelAccessChannel
    
    Returns:
    monitor for this channel using the default event mask.
  - monitorAlarmEnum
```
public ChannelAccessMonitor<ChannelAccessAlarmOnlyEnum> monitorAlarmEnum(ChannelAccessEventMask eventMask)
```
    Description copied from interface: ChannelAccessChannel
    
    Creates a monitor for this channel using the DBR_STS_ENUM data type, the channel's native element count, and the specified event mask. As a channel's native element count might vary over time, the number of elements in the values of monitor events might vary accordingly.
    
    A monitor can be created for a channel that is currently disconnected (or has not yet been connected). However, the monitor will only post events when the channel is connected.
    
    Errors are typically indicated by calling the monitor listeners' monitorError(...) method. Only a destroyed channel will result in an immediate exception thrown by this method.
    
    Specified by:
    
    monitorAlarmEnum in interface ChannelAccessChannel
    
    Parameters:
    eventMask - event mask to use for the monitor. The event mask specifies which events on the server will trigger a monitor event. If null, the default event mask is used.
    
    Returns:
    monitor for this channel using the specified event mask.
  - monitorAlarmEnum
```
public ChannelAccessMonitor<ChannelAccessAlarmOnlyEnum> monitorAlarmEnum(int count)
```
    Description copied from interface: ChannelAccessChannel
    
    Creates a monitor for this channel using the DBR_STS_ENUM data type, the specified element count, and the default event mask.
    
    A monitor can be created for a channel that is currently disconnected (or has not yet been connected). However, the monitor will only post events when the channel is connected.
    
    Errors are typically indicated by calling the monitor listeners' monitorError(...) method. Only errors in the parameters to this method or a destroyed channel will result in an immediate exception thrown by this method.
    
    Specified by:
    
    monitorAlarmEnum in interface ChannelAccessChannel
    
    Parameters:
    count - number of elements to request from the server. Must be positive or zero. A value of zero is interpreted as the channel's native element count. If the specified number exceeds the channel's native element count, the monitor event will only provide the number of elements that is equal to the channel's native element count.
    
    Returns:
    monitor for this channel using the default event mask. The values supplied with monitor events can be expected to not exceed the specified number of elements.
  - monitorAlarmEnum
```
public ChannelAccessMonitor<ChannelAccessAlarmOnlyEnum> monitorAlarmEnum(int count,
                                                                ChannelAccessEventMask eventMask)
```
    Description copied from interface: ChannelAccessChannel
    
    Creates a monitor for this channel using the DBR_STS_ENUM data type, the specified element count, and the specified event mask.
    
    A monitor can be created for a channel that is currently disconnected (or has not yet been connected). However, the monitor will only post events when the channel is connected.
    
    Errors are typically indicated by calling the monitor listeners' monitorError(...) method. Only errors in the parameters to this method or a destroyed channel will result in an immediate exception thrown by this method.
    
    Specified by:
    
    monitorAlarmEnum in interface ChannelAccessChannel
    
    Parameters:
    count - number of elements to request from the server. Must be positive or zero. A value of zero is interpreted as the channel's native element count. If the specified number exceeds the channel's native element count, the monitor event will only provide the number of elements that is equal to the channel's native element count.
    eventMask - event mask to use for the monitor. The event mask specifies which events on the server will trigger a monitor event. If null, the default event mask is used.
    
    Returns:
    monitor for this channel using the specified event mask. The values supplied with monitor events can be expected to not exceed the specified number of elements.
  - monitorTimeEnum
```
public ChannelAccessMonitor<ChannelAccessTimeEnum> monitorTimeEnum()
```
    Description copied from interface: ChannelAccessChannel
    
    Creates a monitor for this channel using the DBR_TIME_ENUM data type, the channel's native element count, and the default event mask. As a channel's native element count might vary over time, the number of elements in the values of monitor events might vary accordingly.
    
    A monitor can be created for a channel that is currently disconnected (or has not yet been connected). However, the monitor will only post events when the channel is connected.
    
    Errors are typically indicated by calling the monitor listeners' monitorError(...) method. Only a destroyed channel will result in an immediate exception thrown by this method.
    
    Specified by:
    
    monitorTimeEnum in interface ChannelAccessChannel
    
    Returns:
    monitor for this channel using the default event mask.
  - monitorTimeEnum
```
public ChannelAccessMonitor<ChannelAccessTimeEnum> monitorTimeEnum(ChannelAccessEventMask eventMask)
```
    Description copied from interface: ChannelAccessChannel
    
    Creates a monitor for this channel using the DBR_TIME_ENUM data type, the channel's native element count, and the specified event mask. As a channel's native element count might vary over time, the number of elements in the values of monitor events might vary accordingly.
    
    A monitor can be created for a channel that is currently disconnected (or has not yet been connected). However, the monitor will only post events when the channel is connected.
    
    Errors are typically indicated by calling the monitor listeners' monitorError(...) method. Only a destroyed channel will result in an immediate exception thrown by this method.
    
    Specified by:
    
    monitorTimeEnum in interface ChannelAccessChannel
    
    Parameters:
    eventMask - event mask to use for the monitor. The event mask specifies which events on the server will trigger a monitor event. If null, the default event mask is used.
    
    Returns:
    monitor for this channel using the specified event mask.
  - monitorTimeEnum
```
public ChannelAccessMonitor<ChannelAccessTimeEnum> monitorTimeEnum(int count)
```
    Description copied from interface: ChannelAccessChannel
    
    Creates a monitor for this channel using the DBR_TIME_ENUM data type, the specified element count, and the default event mask.
    
    A monitor can be created for a channel that is currently disconnected (or has not yet been connected). However, the monitor will only post events when the channel is connected.
    
    Errors are typically indicated by calling the monitor listeners' monitorError(...) method. Only errors in the parameters to this method or a destroyed channel will result in an immediate exception thrown by this method.
    
    Specified by:
    
    monitorTimeEnum in interface ChannelAccessChannel
    
    Parameters:
    count - number of elements to request from the server. Must be positive or zero. A value of zero is interpreted as the channel's native element count. If the specified number exceeds the channel's native element count, the monitor event will only provide the number of elements that is equal to the channel's native element count.
    
    Returns:
    monitor for this channel using the default event mask. The values supplied with monitor events can be expected to not exceed the specified number of elements.
  - monitorTimeEnum
```
public ChannelAccessMonitor<ChannelAccessTimeEnum> monitorTimeEnum(int count,
                                                          ChannelAccessEventMask eventMask)
```
    Description copied from interface: ChannelAccessChannel
    
    Creates a monitor for this channel using the DBR_TIME_ENUM data type, the specified element count, and the specified event mask.
    
    A monitor can be created for a channel that is currently disconnected (or has not yet been connected). However, the monitor will only post events when the channel is connected.
    
    Errors are typically indicated by calling the monitor listeners' monitorError(...) method. Only errors in the parameters to this method or a destroyed channel will result in an immediate exception thrown by this method.
    
    Specified by:
    
    monitorTimeEnum in interface ChannelAccessChannel
    
    Parameters:
    count - number of elements to request from the server. Must be positive or zero. A value of zero is interpreted as the channel's native element count. If the specified number exceeds the channel's native element count, the monitor event will only provide the number of elements that is equal to the channel's native element count.
    eventMask - event mask to use for the monitor. The event mask specifies which events on the server will trigger a monitor event. If null, the default event mask is used.
    
    Returns:
    monitor for this channel using the specified event mask. The values supplied with monitor events can be expected to not exceed the specified number of elements.
  - monitorGraphicsEnum
```
public ChannelAccessMonitor<ChannelAccessGraphicsEnum> monitorGraphicsEnum()
```
    Description copied from interface: ChannelAccessChannel
    
    Creates a monitor for this channel using the DBR_GR_ENUM data type, the channel's native element count, and the default event mask. As a channel's native element count might vary over time, the number of elements in the values of monitor events might vary accordingly.
    
    A monitor can be created for a channel that is currently disconnected (or has not yet been connected). However, the monitor will only post events when the channel is connected.
    
    Errors are typically indicated by calling the monitor listeners' monitorError(...) method. Only a destroyed channel will result in an immediate exception thrown by this method.
    
    Specified by:
    
    monitorGraphicsEnum in interface ChannelAccessChannel
    
    Returns:
    monitor for this channel using the default event mask.
  - monitorGraphicsEnum
```
public ChannelAccessMonitor<ChannelAccessGraphicsEnum> monitorGraphicsEnum(ChannelAccessEventMask eventMask)
```
    Description copied from interface: ChannelAccessChannel
    
    Creates a monitor for this channel using the DBR_GR_ENUM data type, the channel's native element count, and the specified event mask. As a channel's native element count might vary over time, the number of elements in the values of monitor events might vary accordingly.
    
    A monitor can be created for a channel that is currently disconnected (or has not yet been connected). However, the monitor will only post events when the channel is connected.
    
    Errors are typically indicated by calling the monitor listeners' monitorError(...) method. Only a destroyed channel will result in an immediate exception thrown by this method.
    
    Specified by:
    
    monitorGraphicsEnum in interface ChannelAccessChannel
    
    Parameters:
    eventMask - event mask to use for the monitor. The event mask specifies which events on the server will trigger a monitor event. If null, the default event mask is used.
    
    Returns:
    monitor for this channel using the specified event mask.
  - monitorGraphicsEnum
```
public ChannelAccessMonitor<ChannelAccessGraphicsEnum> monitorGraphicsEnum(int count)
```
    Description copied from interface: ChannelAccessChannel
    
    Creates a monitor for this channel using the DBR_GR_ENUM data type, the specified element count, and the default event mask.
    
    A monitor can be created for a channel that is currently disconnected (or has not yet been connected). However, the monitor will only post events when the channel is connected.
    
    Errors are typically indicated by calling the monitor listeners' monitorError(...) method. Only errors in the parameters to this method or a destroyed channel will result in an immediate exception thrown by this method.
    
    Specified by:
    
    monitorGraphicsEnum in interface ChannelAccessChannel
    
    Parameters:
    count - number of elements to request from the server. Must be positive or zero. A value of zero is interpreted as the channel's native element count. If the specified number exceeds the channel's native element count, the monitor event will only provide the number of elements that is equal to the channel's native element count.
    
    Returns:
    monitor for this channel using the default event mask. The values supplied with monitor events can be expected to not exceed the specified number of elements.
  - monitorGraphicsEnum
```
public ChannelAccessMonitor<ChannelAccessGraphicsEnum> monitorGraphicsEnum(int count,
                                                                  ChannelAccessEventMask eventMask)
```
    Description copied from interface: ChannelAccessChannel
    
    Creates a monitor for this channel using the DBR_GR_ENUM data type, the specified element count, and the specified event mask.
    
    A monitor can be created for a channel that is currently disconnected (or has not yet been connected). However, the monitor will only post events when the channel is connected.
    
    Errors are typically indicated by calling the monitor listeners' monitorError(...) method. Only errors in the parameters to this method or a destroyed channel will result in an immediate exception thrown by this method.
    
    Specified by:
    
    monitorGraphicsEnum in interface ChannelAccessChannel
    
    Parameters:
    count - number of elements to request from the server. Must be positive or zero. A value of zero is interpreted as the channel's native element count. If the specified number exceeds the channel's native element count, the monitor event will only provide the number of elements that is equal to the channel's native element count.
    eventMask - event mask to use for the monitor. The event mask specifies which events on the server will trigger a monitor event. If null, the default event mask is used.
    
    Returns:
    monitor for this channel using the specified event mask. The values supplied with monitor events can be expected to not exceed the specified number of elements.
  - monitorControlsEnum
```
public ChannelAccessMonitor<ChannelAccessGraphicsEnum> monitorControlsEnum()
```
    Description copied from interface: ChannelAccessChannel
    
    Creates a monitor for this channel using the DBR_CTRL_ENUM data type, the channel's native element count, and the default event mask. As a channel's native element count might vary over time, the number of elements in the values of monitor events might vary accordingly.
    
    A monitor can be created for a channel that is currently disconnected (or has not yet been connected). However, the monitor will only post events when the channel is connected.
    
    Errors are typically indicated by calling the monitor listeners' monitorError(...) method. Only a destroyed channel will result in an immediate exception thrown by this method.
    
    Specified by:
    
    monitorControlsEnum in interface ChannelAccessChannel
    
    Returns:
    monitor for this channel using the default event mask.
  - monitorControlsEnum
```
public ChannelAccessMonitor<ChannelAccessGraphicsEnum> monitorControlsEnum(ChannelAccessEventMask eventMask)
```
    Description copied from interface: ChannelAccessChannel
    
    Creates a monitor for this channel using the DBR_CTRL_ENUM data type, the channel's native element count, and the specified event mask. As a channel's native element count might vary over time, the number of elements in the values of monitor events might vary accordingly.
    
    A monitor can be created for a channel that is currently disconnected (or has not yet been connected). However, the monitor will only post events when the channel is connected.
    
    Errors are typically indicated by calling the monitor listeners' monitorError(...) method. Only a destroyed channel will result in an immediate exception thrown by this method.
    
    Specified by:
    
    monitorControlsEnum in interface ChannelAccessChannel
    
    Parameters:
    eventMask - event mask to use for the monitor. The event mask specifies which events on the server will trigger a monitor event. If null, the default event mask is used.
    
    Returns:
    monitor for this channel using the specified event mask.
  - monitorControlsEnum
```
public ChannelAccessMonitor<ChannelAccessGraphicsEnum> monitorControlsEnum(int count)
```
    Description copied from interface: ChannelAccessChannel
    
    Creates a monitor for this channel using the DBR_CTRL_ENUM data type, the specified element count, and the default event mask.
    
    A monitor can be created for a channel that is currently disconnected (or has not yet been connected). However, the monitor will only post events when the channel is connected.
    
    Errors are typically indicated by calling the monitor listeners' monitorError(...) method. Only errors in the parameters to this method or a destroyed channel will result in an immediate exception thrown by this method.
    
    Specified by:
    
    monitorControlsEnum in interface ChannelAccessChannel
    
    Parameters:
    count - number of elements to request from the server. Must be positive or zero. A value of zero is interpreted as the channel's native element count. If the specified number exceeds the channel's native element count, the monitor event will only provide the number of elements that is equal to the channel's native element count.
    
    Returns:
    monitor for this channel using the default event mask. The values supplied with monitor events can be expected to not exceed the specified number of elements.
  - monitorControlsEnum
```
public ChannelAccessMonitor<ChannelAccessGraphicsEnum> monitorControlsEnum(int count,
                                                                  ChannelAccessEventMask eventMask)
```
    Description copied from interface: ChannelAccessChannel
    
    Creates a monitor for this channel using the DBR_CTRL_ENUM data type, the specified element count, and the specified event mask.
    
    A monitor can be created for a channel that is currently disconnected (or has not yet been connected). However, the monitor will only post events when the channel is connected.
    
    Errors are typically indicated by calling the monitor listeners' monitorError(...) method. Only errors in the parameters to this method or a destroyed channel will result in an immediate exception thrown by this method.
    
    Specified by:
    
    monitorControlsEnum in interface ChannelAccessChannel
    
    Parameters:
    count - number of elements to request from the server. Must be positive or zero. A value of zero is interpreted as the channel's native element count. If the specified number exceeds the channel's native element count, the monitor event will only provide the number of elements that is equal to the channel's native element count.
    eventMask - event mask to use for the monitor. The event mask specifies which events on the server will trigger a monitor event. If null, the default event mask is used.
    
    Returns:
    monitor for this channel using the specified event mask. The values supplied with monitor events can be expected to not exceed the specified number of elements.
  - monitorChar
```
public ChannelAccessMonitor<ChannelAccessSimpleOnlyChar> monitorChar()
```
    Description copied from interface: ChannelAccessChannel
    
    Creates a monitor for this channel using the DBR_CHAR data type, the channel's native element count, and the default event mask. As a channel's native element count might vary over time, the number of elements in the values of monitor events might vary accordingly.
    
    A monitor can be created for a channel that is currently disconnected (or has not yet been connected). However, the monitor will only post events when the channel is connected.
    
    Errors are typically indicated by calling the monitor listeners' monitorError(...) method. Only a destroyed channel will result in an immediate exception thrown by this method.
    
    Specified by:
    
    monitorChar in interface ChannelAccessChannel
    
    Returns:
    monitor for this channel using the default event mask.
  - monitorChar
```
public ChannelAccessMonitor<ChannelAccessSimpleOnlyChar> monitorChar(ChannelAccessEventMask eventMask)
```
    Description copied from interface: ChannelAccessChannel
    
    Creates a monitor for this channel using the DBR_CHAR data type, the channel's native element count, and the specified event mask. As a channel's native element count might vary over time, the number of elements in the values of monitor events might vary accordingly.
    
    A monitor can be created for a channel that is currently disconnected (or has not yet been connected). However, the monitor will only post events when the channel is connected.
    
    Errors are typically indicated by calling the monitor listeners' monitorError(...) method. Only a destroyed channel will result in an immediate exception thrown by this method.
    
    Specified by:
    
    monitorChar in interface ChannelAccessChannel
    
    Parameters:
    eventMask - event mask to use for the monitor. The event mask specifies which events on the server will trigger a monitor event. If null, the default event mask is used.
    
    Returns:
    monitor for this channel using the specified event mask.
  - monitorChar
```
public ChannelAccessMonitor<ChannelAccessSimpleOnlyChar> monitorChar(int count)
```
    Description copied from interface: ChannelAccessChannel
    
    Creates a monitor for this channel using the DBR_CHAR data type, the specified element count, and the default event mask.
    
    A monitor can be created for a channel that is currently disconnected (or has not yet been connected). However, the monitor will only post events when the channel is connected.
    
    Errors are typically indicated by calling the monitor listeners' monitorError(...) method. Only errors in the parameters to this method or a destroyed channel will result in an immediate exception thrown by this method.
    
    Specified by:
    
    monitorChar in interface ChannelAccessChannel
    
    Parameters:
    count - number of elements to request from the server. Must be positive or zero. A value of zero is interpreted as the channel's native element count. If the specified number exceeds the channel's native element count, the monitor event will only provide the number of elements that is equal to the channel's native element count.
    
    Returns:
    monitor for this channel using the default event mask. The values supplied with monitor events can be expected to not exceed the specified number of elements.
  - monitorChar
```
public ChannelAccessMonitor<ChannelAccessSimpleOnlyChar> monitorChar(int count,
                                                            ChannelAccessEventMask eventMask)
```
    Description copied from interface: ChannelAccessChannel
    
    Creates a monitor for this channel using the DBR_CHAR data type, the specified element count, and the specified event mask.
    
    A monitor can be created for a channel that is currently disconnected (or has not yet been connected). However, the monitor will only post events when the channel is connected.
    
    Errors are typically indicated by calling the monitor listeners' monitorError(...) method. Only errors in the parameters to this method or a destroyed channel will result in an immediate exception thrown by this method.
    
    Specified by:
    
    monitorChar in interface ChannelAccessChannel
    
    Parameters:
    count - number of elements to request from the server. Must be positive or zero. A value of zero is interpreted as the channel's native element count. If the specified number exceeds the channel's native element count, the monitor event will only provide the number of elements that is equal to the channel's native element count.
    eventMask - event mask to use for the monitor. The event mask specifies which events on the server will trigger a monitor event. If null, the default event mask is used.
    
    Returns:
    monitor for this channel using the specified event mask. The values supplied with monitor events can be expected to not exceed the specified number of elements.
  - monitorAlarmChar
```
public ChannelAccessMonitor<ChannelAccessAlarmOnlyChar> monitorAlarmChar()
```
    Description copied from interface: ChannelAccessChannel
    
    Creates a monitor for this channel using the DBR_STS_CHAR data type, the channel's native element count, and the default event mask. As a channel's native element count might vary over time, the number of elements in the values of monitor events might vary accordingly.
    
    A monitor can be created for a channel that is currently disconnected (or has not yet been connected). However, the monitor will only post events when the channel is connected.
    
    Errors are typically indicated by calling the monitor listeners' monitorError(...) method. Only a destroyed channel will result in an immediate exception thrown by this method.
    
    Specified by:
    
    monitorAlarmChar in interface ChannelAccessChannel
    
    Returns:
    monitor for this channel using the default event mask.
  - monitorAlarmChar
```
public ChannelAccessMonitor<ChannelAccessAlarmOnlyChar> monitorAlarmChar(ChannelAccessEventMask eventMask)
```
    Description copied from interface: ChannelAccessChannel
    
    Creates a monitor for this channel using the DBR_STS_CHAR data type, the channel's native element count, and the specified event mask. As a channel's native element count might vary over time, the number of elements in the values of monitor events might vary accordingly.
    
    A monitor can be created for a channel that is currently disconnected (or has not yet been connected). However, the monitor will only post events when the channel is connected.
    
    Errors are typically indicated by calling the monitor listeners' monitorError(...) method. Only a destroyed channel will result in an immediate exception thrown by this method.
    
    Specified by:
    
    monitorAlarmChar in interface ChannelAccessChannel
    
    Parameters:
    eventMask - event mask to use for the monitor. The event mask specifies which events on the server will trigger a monitor event. If null, the default event mask is used.
    
    Returns:
    monitor for this channel using the specified event mask.
  - monitorAlarmChar
```
public ChannelAccessMonitor<ChannelAccessAlarmOnlyChar> monitorAlarmChar(int count)
```
    Description copied from interface: ChannelAccessChannel
    
    Creates a monitor for this channel using the DBR_STS_CHAR data type, the specified element count, and the default event mask.
    
    A monitor can be created for a channel that is currently disconnected (or has not yet been connected). However, the monitor will only post events when the channel is connected.
    
    Errors are typically indicated by calling the monitor listeners' monitorError(...) method. Only errors in the parameters to this method or a destroyed channel will result in an immediate exception thrown by this method.
    
    Specified by:
    
    monitorAlarmChar in interface ChannelAccessChannel
    
    Parameters:
    count - number of elements to request from the server. Must be positive or zero. A value of zero is interpreted as the channel's native element count. If the specified number exceeds the channel's native element count, the monitor event will only provide the number of elements that is equal to the channel's native element count.
    
    Returns:
    monitor for this channel using the default event mask. The values supplied with monitor events can be expected to not exceed the specified number of elements.
  - monitorAlarmChar
```
public ChannelAccessMonitor<ChannelAccessAlarmOnlyChar> monitorAlarmChar(int count,
                                                                ChannelAccessEventMask eventMask)
```
    Description copied from interface: ChannelAccessChannel
    
    Creates a monitor for this channel using the DBR_STS_CHAR data type, the specified element count, and the specified event mask.
    
    A monitor can be created for a channel that is currently disconnected (or has not yet been connected). However, the monitor will only post events when the channel is connected.
    
    Errors are typically indicated by calling the monitor listeners' monitorError(...) method. Only errors in the parameters to this method or a destroyed channel will result in an immediate exception thrown by this method.
    
    Specified by:
    
    monitorAlarmChar in interface ChannelAccessChannel
    
    Parameters:
    count - number of elements to request from the server. Must be positive or zero. A value of zero is interpreted as the channel's native element count. If the specified number exceeds the channel's native element count, the monitor event will only provide the number of elements that is equal to the channel's native element count.
    eventMask - event mask to use for the monitor. The event mask specifies which events on the server will trigger a monitor event. If null, the default event mask is used.
    
    Returns:
    monitor for this channel using the specified event mask. The values supplied with monitor events can be expected to not exceed the specified number of elements.
  - monitorTimeChar
```
public ChannelAccessMonitor<ChannelAccessTimeChar> monitorTimeChar()
```
    Description copied from interface: ChannelAccessChannel
    
    Creates a monitor for this channel using the DBR_TIME_CHAR data type, the channel's native element count, and the default event mask. As a channel's native element count might vary over time, the number of elements in the values of monitor events might vary accordingly.
    
    A monitor can be created for a channel that is currently disconnected (or has not yet been connected). However, the monitor will only post events when the channel is connected.
    
    Errors are typically indicated by calling the monitor listeners' monitorError(...) method. Only a destroyed channel will result in an immediate exception thrown by this method.
    
    Specified by:
    
    monitorTimeChar in interface ChannelAccessChannel
    
    Returns:
    monitor for this channel using the default event mask.
  - monitorTimeChar
```
public ChannelAccessMonitor<ChannelAccessTimeChar> monitorTimeChar(ChannelAccessEventMask eventMask)
```
    Description copied from interface: ChannelAccessChannel
    
    Creates a monitor for this channel using the DBR_TIME_CHAR data type, the channel's native element count, and the specified event mask. As a channel's native element count might vary over time, the number of elements in the values of monitor events might vary accordingly.
    
    A monitor can be created for a channel that is currently disconnected (or has not yet been connected). However, the monitor will only post events when the channel is connected.
    
    Errors are typically indicated by calling the monitor listeners' monitorError(...) method. Only a destroyed channel will result in an immediate exception thrown by this method.
    
    Specified by:
    
    monitorTimeChar in interface ChannelAccessChannel
    
    Parameters:
    eventMask - event mask to use for the monitor. The event mask specifies which events on the server will trigger a monitor event. If null, the default event mask is used.
    
    Returns:
    monitor for this channel using the specified event mask.
  - monitorTimeChar
```
public ChannelAccessMonitor<ChannelAccessTimeChar> monitorTimeChar(int count)
```
    Description copied from interface: ChannelAccessChannel
    
    Creates a monitor for this channel using the DBR_TIME_CHAR data type, the specified element count, and the default event mask.
    
    A monitor can be created for a channel that is currently disconnected (or has not yet been connected). However, the monitor will only post events when the channel is connected.
    
    Errors are typically indicated by calling the monitor listeners' monitorError(...) method. Only errors in the parameters to this method or a destroyed channel will result in an immediate exception thrown by this method.
    
    Specified by:
    
    monitorTimeChar in interface ChannelAccessChannel
    
    Parameters:
    count - number of elements to request from the server. Must be positive or zero. A value of zero is interpreted as the channel's native element count. If the specified number exceeds the channel's native element count, the monitor event will only provide the number of elements that is equal to the channel's native element count.
    
    Returns:
    monitor for this channel using the default event mask. The values supplied with monitor events can be expected to not exceed the specified number of elements.
  - monitorTimeChar
```
public ChannelAccessMonitor<ChannelAccessTimeChar> monitorTimeChar(int count,
                                                          ChannelAccessEventMask eventMask)
```
    Description copied from interface: ChannelAccessChannel
    
    Creates a monitor for this channel using the DBR_TIME_CHAR data type, the specified element count, and the specified event mask.
    
    A monitor can be created for a channel that is currently disconnected (or has not yet been connected). However, the monitor will only post events when the channel is connected.
    
    Errors are typically indicated by calling the monitor listeners' monitorError(...) method. Only errors in the parameters to this method or a destroyed channel will result in an immediate exception thrown by this method.
    
    Specified by:
    
    monitorTimeChar in interface ChannelAccessChannel
    
    Parameters:
    count - number of elements to request from the server. Must be positive or zero. A value of zero is interpreted as the channel's native element count. If the specified number exceeds the channel's native element count, the monitor event will only provide the number of elements that is equal to the channel's native element count.
    eventMask - event mask to use for the monitor. The event mask specifies which events on the server will trigger a monitor event. If null, the default event mask is used.
    
    Returns:
    monitor for this channel using the specified event mask. The values supplied with monitor events can be expected to not exceed the specified number of elements.
  - monitorGraphicsChar
```
public ChannelAccessMonitor<ChannelAccessGraphicsOnlyChar> monitorGraphicsChar()
```
    Description copied from interface: ChannelAccessChannel
    
    Creates a monitor for this channel using the DBR_GR_CHAR data type, the channel's native element count, and the default event mask. As a channel's native element count might vary over time, the number of elements in the values of monitor events might vary accordingly.
    
    A monitor can be created for a channel that is currently disconnected (or has not yet been connected). However, the monitor will only post events when the channel is connected.
    
    Errors are typically indicated by calling the monitor listeners' monitorError(...) method. Only a destroyed channel will result in an immediate exception thrown by this method.
    
    Specified by:
    
    monitorGraphicsChar in interface ChannelAccessChannel
    
    Returns:
    monitor for this channel using the default event mask.
  - monitorGraphicsChar
```
public ChannelAccessMonitor<ChannelAccessGraphicsOnlyChar> monitorGraphicsChar(ChannelAccessEventMask eventMask)
```
    Description copied from interface: ChannelAccessChannel
    
    Creates a monitor for this channel using the DBR_GR_CHAR data type, the channel's native element count, and the specified event mask. As a channel's native element count might vary over time, the number of elements in the values of monitor events might vary accordingly.
    
    A monitor can be created for a channel that is currently disconnected (or has not yet been connected). However, the monitor will only post events when the channel is connected.
    
    Errors are typically indicated by calling the monitor listeners' monitorError(...) method. Only a destroyed channel will result in an immediate exception thrown by this method.
    
    Specified by:
    
    monitorGraphicsChar in interface ChannelAccessChannel
    
    Parameters:
    eventMask - event mask to use for the monitor. The event mask specifies which events on the server will trigger a monitor event. If null, the default event mask is used.
    
    Returns:
    monitor for this channel using the specified event mask.
  - monitorGraphicsChar
```
public ChannelAccessMonitor<ChannelAccessGraphicsOnlyChar> monitorGraphicsChar(int count)
```
    Description copied from interface: ChannelAccessChannel
    
    Creates a monitor for this channel using the DBR_GR_CHAR data type, the specified element count, and the default event mask.
    
    A monitor can be created for a channel that is currently disconnected (or has not yet been connected). However, the monitor will only post events when the channel is connected.
    
    Errors are typically indicated by calling the monitor listeners' monitorError(...) method. Only errors in the parameters to this method or a destroyed channel will result in an immediate exception thrown by this method.
    
    Specified by:
    
    monitorGraphicsChar in interface ChannelAccessChannel
    
    Parameters:
    count - number of elements to request from the server. Must be positive or zero. A value of zero is interpreted as the channel's native element count. If the specified number exceeds the channel's native element count, the monitor event will only provide the number of elements that is equal to the channel's native element count.
    
    Returns:
    monitor for this channel using the default event mask. The values supplied with monitor events can be expected to not exceed the specified number of elements.
  - monitorGraphicsChar
```
public ChannelAccessMonitor<ChannelAccessGraphicsOnlyChar> monitorGraphicsChar(int count,
                                                                      ChannelAccessEventMask eventMask)
```
    Description copied from interface: ChannelAccessChannel
    
    Creates a monitor for this channel using the DBR_GR_CHAR data type, the specified element count, and the specified event mask.
    
    A monitor can be created for a channel that is currently disconnected (or has not yet been connected). However, the monitor will only post events when the channel is connected.
    
    Errors are typically indicated by calling the monitor listeners' monitorError(...) method. Only errors in the parameters to this method or a destroyed channel will result in an immediate exception thrown by this method.
    
    Specified by:
    
    monitorGraphicsChar in interface ChannelAccessChannel
    
    Parameters:
    count - number of elements to request from the server. Must be positive or zero. A value of zero is interpreted as the channel's native element count. If the specified number exceeds the channel's native element count, the monitor event will only provide the number of elements that is equal to the channel's native element count.
    eventMask - event mask to use for the monitor. The event mask specifies which events on the server will trigger a monitor event. If null, the default event mask is used.
    
    Returns:
    monitor for this channel using the specified event mask. The values supplied with monitor events can be expected to not exceed the specified number of elements.
  - monitorControlsChar
```
public ChannelAccessMonitor<ChannelAccessControlsChar> monitorControlsChar()
```
    Description copied from interface: ChannelAccessChannel
    
    Creates a monitor for this channel using the DBR_CTRL_CHAR data type, the channel's native element count, and the default event mask. As a channel's native element count might vary over time, the number of elements in the values of monitor events might vary accordingly.
    
    A monitor can be created for a channel that is currently disconnected (or has not yet been connected). However, the monitor will only post events when the channel is connected.
    
    Errors are typically indicated by calling the monitor listeners' monitorError(...) method. Only a destroyed channel will result in an immediate exception thrown by this method.
    
    Specified by:
    
    monitorControlsChar in interface ChannelAccessChannel
    
    Returns:
    monitor for this channel using the default event mask.
  - monitorControlsChar
```
public ChannelAccessMonitor<ChannelAccessControlsChar> monitorControlsChar(ChannelAccessEventMask eventMask)
```
    Description copied from interface: ChannelAccessChannel
    
    Creates a monitor for this channel using the DBR_CTRL_CHAR data type, the channel's native element count, and the specified event mask. As a channel's native element count might vary over time, the number of elements in the values of monitor events might vary accordingly.
    
    A monitor can be created for a channel that is currently disconnected (or has not yet been connected). However, the monitor will only post events when the channel is connected.
    
    Errors are typically indicated by calling the monitor listeners' monitorError(...) method. Only a destroyed channel will result in an immediate exception thrown by this method.
    
    Specified by:
    
    monitorControlsChar in interface ChannelAccessChannel
    
    Parameters:
    eventMask - event mask to use for the monitor. The event mask specifies which events on the server will trigger a monitor event. If null, the default event mask is used.
    
    Returns:
    monitor for this channel using the specified event mask.
  - monitorControlsChar
```
public ChannelAccessMonitor<ChannelAccessControlsChar> monitorControlsChar(int count)
```
    Description copied from interface: ChannelAccessChannel
    
    Creates a monitor for this channel using the DBR_CTRL_CHAR data type, the specified element count, and the default event mask.
    
    A monitor can be created for a channel that is currently disconnected (or has not yet been connected). However, the monitor will only post events when the channel is connected.
    
    Errors are typically indicated by calling the monitor listeners' monitorError(...) method. Only errors in the parameters to this method or a destroyed channel will result in an immediate exception thrown by this method.
    
    Specified by:
    
    monitorControlsChar in interface ChannelAccessChannel
    
    Parameters:
    count - number of elements to request from the server. Must be positive or zero. A value of zero is interpreted as the channel's native element count. If the specified number exceeds the channel's native element count, the monitor event will only provide the number of elements that is equal to the channel's native element count.
    
    Returns:
    monitor for this channel using the default event mask. The values supplied with monitor events can be expected to not exceed the specified number of elements.
  - monitorControlsChar
```
public ChannelAccessMonitor<ChannelAccessControlsChar> monitorControlsChar(int count,
                                                                  ChannelAccessEventMask eventMask)
```
    Description copied from interface: ChannelAccessChannel
    
    Creates a monitor for this channel using the DBR_CTRL_CHAR data type, the specified element count, and the specified event mask.
    
    A monitor can be created for a channel that is currently disconnected (or has not yet been connected). However, the monitor will only post events when the channel is connected.
    
    Errors are typically indicated by calling the monitor listeners' monitorError(...) method. Only errors in the parameters to this method or a destroyed channel will result in an immediate exception thrown by this method.
    
    Specified by:
    
    monitorControlsChar in interface ChannelAccessChannel
    
    Parameters:
    count - number of elements to request from the server. Must be positive or zero. A value of zero is interpreted as the channel's native element count. If the specified number exceeds the channel's native element count, the monitor event will only provide the number of elements that is equal to the channel's native element count.
    eventMask - event mask to use for the monitor. The event mask specifies which events on the server will trigger a monitor event. If null, the default event mask is used.
    
    Returns:
    monitor for this channel using the specified event mask. The values supplied with monitor events can be expected to not exceed the specified number of elements.
  - monitorLong
```
public ChannelAccessMonitor<ChannelAccessSimpleOnlyLong> monitorLong()
```
    Description copied from interface: ChannelAccessChannel
    
    Creates a monitor for this channel using the DBR_LONG data type, the channel's native element count, and the default event mask. As a channel's native element count might vary over time, the number of elements in the values of monitor events might vary accordingly.
    
    A monitor can be created for a channel that is currently disconnected (or has not yet been connected). However, the monitor will only post events when the channel is connected.
    
    Errors are typically indicated by calling the monitor listeners' monitorError(...) method. Only a destroyed channel will result in an immediate exception thrown by this method.
    
    Specified by:
    
    monitorLong in interface ChannelAccessChannel
    
    Returns:
    monitor for this channel using the default event mask.
  - monitorLong
```
public ChannelAccessMonitor<ChannelAccessSimpleOnlyLong> monitorLong(ChannelAccessEventMask eventMask)
```
    Description copied from interface: ChannelAccessChannel
    
    Creates a monitor for this channel using the DBR_LONG data type, the channel's native element count, and the specified event mask. As a channel's native element count might vary over time, the number of elements in the values of monitor events might vary accordingly.
    
    A monitor can be created for a channel that is currently disconnected (or has not yet been connected). However, the monitor will only post events when the channel is connected.
    
    Errors are typically indicated by calling the monitor listeners' monitorError(...) method. Only a destroyed channel will result in an immediate exception thrown by this method.
    
    Specified by:
    
    monitorLong in interface ChannelAccessChannel
    
    Parameters:
    eventMask - event mask to use for the monitor. The event mask specifies which events on the server will trigger a monitor event. If null, the default event mask is used.
    
    Returns:
    monitor for this channel using the specified event mask.
  - monitorLong
```
public ChannelAccessMonitor<ChannelAccessSimpleOnlyLong> monitorLong(int count)
```
    Description copied from interface: ChannelAccessChannel
    
    Creates a monitor for this channel using the DBR_LONG data type, the specified element count, and the default event mask.
    
    A monitor can be created for a channel that is currently disconnected (or has not yet been connected). However, the monitor will only post events when the channel is connected.
    
    Errors are typically indicated by calling the monitor listeners' monitorError(...) method. Only errors in the parameters to this method or a destroyed channel will result in an immediate exception thrown by this method.
    
    Specified by:
    
    monitorLong in interface ChannelAccessChannel
    
    Parameters:
    count - number of elements to request from the server. Must be positive or zero. A value of zero is interpreted as the channel's native element count. If the specified number exceeds the channel's native element count, the monitor event will only provide the number of elements that is equal to the channel's native element count.
    
    Returns:
    monitor for this channel using the default event mask. The values supplied with monitor events can be expected to not exceed the specified number of elements.
  - monitorLong
```
public ChannelAccessMonitor<ChannelAccessSimpleOnlyLong> monitorLong(int count,
                                                            ChannelAccessEventMask eventMask)
```
    Description copied from interface: ChannelAccessChannel
    
    Creates a monitor for this channel using the DBR_LONG data type, the specified element count, and the specified event mask.
    
    A monitor can be created for a channel that is currently disconnected (or has not yet been connected). However, the monitor will only post events when the channel is connected.
    
    Errors are typically indicated by calling the monitor listeners' monitorError(...) method. Only errors in the parameters to this method or a destroyed channel will result in an immediate exception thrown by this method.
    
    Specified by:
    
    monitorLong in interface ChannelAccessChannel
    
    Parameters:
    count - number of elements to request from the server. Must be positive or zero. A value of zero is interpreted as the channel's native element count. If the specified number exceeds the channel's native element count, the monitor event will only provide the number of elements that is equal to the channel's native element count.
    eventMask - event mask to use for the monitor. The event mask specifies which events on the server will trigger a monitor event. If null, the default event mask is used.
    
    Returns:
    monitor for this channel using the specified event mask. The values supplied with monitor events can be expected to not exceed the specified number of elements.
  - monitorAlarmLong
```
public ChannelAccessMonitor<ChannelAccessAlarmOnlyLong> monitorAlarmLong()
```
    Description copied from interface: ChannelAccessChannel
    
    Creates a monitor for this channel using the DBR_STS_LONG data type, the channel's native element count, and the default event mask. As a channel's native element count might vary over time, the number of elements in the values of monitor events might vary accordingly.
    
    A monitor can be created for a channel that is currently disconnected (or has not yet been connected). However, the monitor will only post events when the channel is connected.
    
    Errors are typically indicated by calling the monitor listeners' monitorError(...) method. Only a destroyed channel will result in an immediate exception thrown by this method.
    
    Specified by:
    
    monitorAlarmLong in interface ChannelAccessChannel
    
    Returns:
    monitor for this channel using the default event mask.
  - monitorAlarmLong
```
public ChannelAccessMonitor<ChannelAccessAlarmOnlyLong> monitorAlarmLong(ChannelAccessEventMask eventMask)
```
    Description copied from interface: ChannelAccessChannel
    
    Creates a monitor for this channel using the DBR_STS_LONG data type, the channel's native element count, and the specified event mask. As a channel's native element count might vary over time, the number of elements in the values of monitor events might vary accordingly.
    
    A monitor can be created for a channel that is currently disconnected (or has not yet been connected). However, the monitor will only post events when the channel is connected.
    
    Errors are typically indicated by calling the monitor listeners' monitorError(...) method. Only a destroyed channel will result in an immediate exception thrown by this method.
    
    Specified by:
    
    monitorAlarmLong in interface ChannelAccessChannel
    
    Parameters:
    eventMask - event mask to use for the monitor. The event mask specifies which events on the server will trigger a monitor event. If null, the default event mask is used.
    
    Returns:
    monitor for this channel using the specified event mask.
  - monitorAlarmLong
```
public ChannelAccessMonitor<ChannelAccessAlarmOnlyLong> monitorAlarmLong(int count)
```
    Description copied from interface: ChannelAccessChannel
    
    Creates a monitor for this channel using the DBR_STS_LONG data type, the specified element count, and the default event mask.
    
    A monitor can be created for a channel that is currently disconnected (or has not yet been connected). However, the monitor will only post events when the channel is connected.
    
    Errors are typically indicated by calling the monitor listeners' monitorError(...) method. Only errors in the parameters to this method or a destroyed channel will result in an immediate exception thrown by this method.
    
    Specified by:
    
    monitorAlarmLong in interface ChannelAccessChannel
    
    Parameters:
    count - number of elements to request from the server. Must be positive or zero. A value of zero is interpreted as the channel's native element count. If the specified number exceeds the channel's native element count, the monitor event will only provide the number of elements that is equal to the channel's native element count.
    
    Returns:
    monitor for this channel using the default event mask. The values supplied with monitor events can be expected to not exceed the specified number of elements.
  - monitorAlarmLong
```
public ChannelAccessMonitor<ChannelAccessAlarmOnlyLong> monitorAlarmLong(int count,
                                                                ChannelAccessEventMask eventMask)
```
    Description copied from interface: ChannelAccessChannel
    
    Creates a monitor for this channel using the DBR_STS_LONG data type, the specified element count, and the specified event mask.
    
    A monitor can be created for a channel that is currently disconnected (or has not yet been connected). However, the monitor will only post events when the channel is connected.
    
    Errors are typically indicated by calling the monitor listeners' monitorError(...) method. Only errors in the parameters to this method or a destroyed channel will result in an immediate exception thrown by this method.
    
    Specified by:
    
    monitorAlarmLong in interface ChannelAccessChannel
    
    Parameters:
    count - number of elements to request from the server. Must be positive or zero. A value of zero is interpreted as the channel's native element count. If the specified number exceeds the channel's native element count, the monitor event will only provide the number of elements that is equal to the channel's native element count.
    eventMask - event mask to use for the monitor. The event mask specifies which events on the server will trigger a monitor event. If null, the default event mask is used.
    
    Returns:
    monitor for this channel using the specified event mask. The values supplied with monitor events can be expected to not exceed the specified number of elements.
  - monitorTimeLong
```
public ChannelAccessMonitor<ChannelAccessTimeLong> monitorTimeLong()
```
    Description copied from interface: ChannelAccessChannel
    
    Creates a monitor for this channel using the DBR_TIME_LONG data type, the channel's native element count, and the default event mask. As a channel's native element count might vary over time, the number of elements in the values of monitor events might vary accordingly.
    
    A monitor can be created for a channel that is currently disconnected (or has not yet been connected). However, the monitor will only post events when the channel is connected.
    
    Errors are typically indicated by calling the monitor listeners' monitorError(...) method. Only a destroyed channel will result in an immediate exception thrown by this method.
    
    Specified by:
    
    monitorTimeLong in interface ChannelAccessChannel
    
    Returns:
    monitor for this channel using the default event mask.
  - monitorTimeLong
```
public ChannelAccessMonitor<ChannelAccessTimeLong> monitorTimeLong(ChannelAccessEventMask eventMask)
```
    Description copied from interface: ChannelAccessChannel
    
    Creates a monitor for this channel using the DBR_TIME_LONG data type, the channel's native element count, and the specified event mask. As a channel's native element count might vary over time, the number of elements in the values of monitor events might vary accordingly.
    
    A monitor can be created for a channel that is currently disconnected (or has not yet been connected). However, the monitor will only post events when the channel is connected.
    
    Errors are typically indicated by calling the monitor listeners' monitorError(...) method. Only a destroyed channel will result in an immediate exception thrown by this method.
    
    Specified by:
    
    monitorTimeLong in interface ChannelAccessChannel
    
    Parameters:
    eventMask - event mask to use for the monitor. The event mask specifies which events on the server will trigger a monitor event. If null, the default event mask is used.
    
    Returns:
    monitor for this channel using the specified event mask.
  - monitorTimeLong
```
public ChannelAccessMonitor<ChannelAccessTimeLong> monitorTimeLong(int count)
```
    Description copied from interface: ChannelAccessChannel
    
    Creates a monitor for this channel using the DBR_TIME_LONG data type, the specified element count, and the default event mask.
    
    A monitor can be created for a channel that is currently disconnected (or has not yet been connected). However, the monitor will only post events when the channel is connected.
    
    Errors are typically indicated by calling the monitor listeners' monitorError(...) method. Only errors in the parameters to this method or a destroyed channel will result in an immediate exception thrown by this method.
    
    Specified by:
    
    monitorTimeLong in interface ChannelAccessChannel
    
    Parameters:
    count - number of elements to request from the server. Must be positive or zero. A value of zero is interpreted as the channel's native element count. If the specified number exceeds the channel's native element count, the monitor event will only provide the number of elements that is equal to the channel's native element count.
    
    Returns:
    monitor for this channel using the default event mask. The values supplied with monitor events can be expected to not exceed the specified number of elements.
  - monitorTimeLong
```
public ChannelAccessMonitor<ChannelAccessTimeLong> monitorTimeLong(int count,
                                                          ChannelAccessEventMask eventMask)
```
    Description copied from interface: ChannelAccessChannel
    
    Creates a monitor for this channel using the DBR_TIME_LONG data type, the specified element count, and the specified event mask.
    
    A monitor can be created for a channel that is currently disconnected (or has not yet been connected). However, the monitor will only post events when the channel is connected.
    
    Errors are typically indicated by calling the monitor listeners' monitorError(...) method. Only errors in the parameters to this method or a destroyed channel will result in an immediate exception thrown by this method.
    
    Specified by:
    
    monitorTimeLong in interface ChannelAccessChannel
    
    Parameters:
    count - number of elements to request from the server. Must be positive or zero. A value of zero is interpreted as the channel's native element count. If the specified number exceeds the channel's native element count, the monitor event will only provide the number of elements that is equal to the channel's native element count.
    eventMask - event mask to use for the monitor. The event mask specifies which events on the server will trigger a monitor event. If null, the default event mask is used.
    
    Returns:
    monitor for this channel using the specified event mask. The values supplied with monitor events can be expected to not exceed the specified number of elements.
  - monitorGraphicsLong
```
public ChannelAccessMonitor<ChannelAccessGraphicsOnlyLong> monitorGraphicsLong()
```
    Description copied from interface: ChannelAccessChannel
    
    Creates a monitor for this channel using the DBR_GR_LONG data type, the channel's native element count, and the default event mask. As a channel's native element count might vary over time, the number of elements in the values of monitor events might vary accordingly.
    
    A monitor can be created for a channel that is currently disconnected (or has not yet been connected). However, the monitor will only post events when the channel is connected.
    
    Errors are typically indicated by calling the monitor listeners' monitorError(...) method. Only a destroyed channel will result in an immediate exception thrown by this method.
    
    Specified by:
    
    monitorGraphicsLong in interface ChannelAccessChannel
    
    Returns:
    monitor for this channel using the default event mask.
  - monitorGraphicsLong
```
public ChannelAccessMonitor<ChannelAccessGraphicsOnlyLong> monitorGraphicsLong(ChannelAccessEventMask eventMask)
```
    Description copied from interface: ChannelAccessChannel
    
    Creates a monitor for this channel using the DBR_GR_LONG data type, the channel's native element count, and the specified event mask. As a channel's native element count might vary over time, the number of elements in the values of monitor events might vary accordingly.
    
    A monitor can be created for a channel that is currently disconnected (or has not yet been connected). However, the monitor will only post events when the channel is connected.
    
    Errors are typically indicated by calling the monitor listeners' monitorError(...) method. Only a destroyed channel will result in an immediate exception thrown by this method.
    
    Specified by:
    
    monitorGraphicsLong in interface ChannelAccessChannel
    
    Parameters:
    eventMask - event mask to use for the monitor. The event mask specifies which events on the server will trigger a monitor event. If null, the default event mask is used.
    
    Returns:
    monitor for this channel using the specified event mask.
  - monitorGraphicsLong
```
public ChannelAccessMonitor<ChannelAccessGraphicsOnlyLong> monitorGraphicsLong(int count)
```
    Description copied from interface: ChannelAccessChannel
    
    Creates a monitor for this channel using the DBR_GR_LONG data type, the specified element count, and the default event mask.
    
    A monitor can be created for a channel that is currently disconnected (or has not yet been connected). However, the monitor will only post events when the channel is connected.
    
    Errors are typically indicated by calling the monitor listeners' monitorError(...) method. Only errors in the parameters to this method or a destroyed channel will result in an immediate exception thrown by this method.
    
    Specified by:
    
    monitorGraphicsLong in interface ChannelAccessChannel
    
    Parameters:
    count - number of elements to request from the server. Must be positive or zero. A value of zero is interpreted as the channel's native element count. If the specified number exceeds the channel's native element count, the monitor event will only provide the number of elements that is equal to the channel's native element count.
    
    Returns:
    monitor for this channel using the default event mask. The values supplied with monitor events can be expected to not exceed the specified number of elements.
  - monitorGraphicsLong
```
public ChannelAccessMonitor<ChannelAccessGraphicsOnlyLong> monitorGraphicsLong(int count,
                                                                      ChannelAccessEventMask eventMask)
```
    Description copied from interface: ChannelAccessChannel
    
    Creates a monitor for this channel using the DBR_GR_LONG data type, the specified element count, and the specified event mask.
    
    A monitor can be created for a channel that is currently disconnected (or has not yet been connected). However, the monitor will only post events when the channel is connected.
    
    Errors are typically indicated by calling the monitor listeners' monitorError(...) method. Only errors in the parameters to this method or a destroyed channel will result in an immediate exception thrown by this method.
    
    Specified by:
    
    monitorGraphicsLong in interface ChannelAccessChannel
    
    Parameters:
    count - number of elements to request from the server. Must be positive or zero. A value of zero is interpreted as the channel's native element count. If the specified number exceeds the channel's native element count, the monitor event will only provide the number of elements that is equal to the channel's native element count.
    eventMask - event mask to use for the monitor. The event mask specifies which events on the server will trigger a monitor event. If null, the default event mask is used.
    
    Returns:
    monitor for this channel using the specified event mask. The values supplied with monitor events can be expected to not exceed the specified number of elements.
  - monitorControlsLong
```
public ChannelAccessMonitor<ChannelAccessControlsLong> monitorControlsLong()
```
    Description copied from interface: ChannelAccessChannel
    
    Creates a monitor for this channel using the DBR_CTRL_LONG data type, the channel's native element count, and the default event mask. As a channel's native element count might vary over time, the number of elements in the values of monitor events might vary accordingly.
    
    A monitor can be created for a channel that is currently disconnected (or has not yet been connected). However, the monitor will only post events when the channel is connected.
    
    Errors are typically indicated by calling the monitor listeners' monitorError(...) method. Only a destroyed channel will result in an immediate exception thrown by this method.
    
    Specified by:
    
    monitorControlsLong in interface ChannelAccessChannel
    
    Returns:
    monitor for this channel using the default event mask.
  - monitorControlsLong
```
public ChannelAccessMonitor<ChannelAccessControlsLong> monitorControlsLong(ChannelAccessEventMask eventMask)
```
    Description copied from interface: ChannelAccessChannel
    
    Creates a monitor for this channel using the DBR_CTLR_LONG data type, the channel's native element count, and the specified event mask. As a channel's native element count might vary over time, the number of elements in the values of monitor events might vary accordingly.
    
    A monitor can be created for a channel that is currently disconnected (or has not yet been connected). However, the monitor will only post events when the channel is connected.
    
    Errors are typically indicated by calling the monitor listeners' monitorError(...) method. Only a destroyed channel will result in an immediate exception thrown by this method.
    
    Specified by:
    
    monitorControlsLong in interface ChannelAccessChannel
    
    Parameters:
    eventMask - event mask to use for the monitor. The event mask specifies which events on the server will trigger a monitor event. If null, the default event mask is used.
    
    Returns:
    monitor for this channel using the specified event mask.
  - monitorControlsLong
```
public ChannelAccessMonitor<ChannelAccessControlsLong> monitorControlsLong(int count)
```
    Description copied from interface: ChannelAccessChannel
    
    Creates a monitor for this channel using the DBR_CTRL_LONG data type, the specified element count, and the default event mask.
    
    A monitor can be created for a channel that is currently disconnected (or has not yet been connected). However, the monitor will only post events when the channel is connected.
    
    Errors are typically indicated by calling the monitor listeners' monitorError(...) method. Only errors in the parameters to this method or a destroyed channel will result in an immediate exception thrown by this method.
    
    Specified by:
    
    monitorControlsLong in interface ChannelAccessChannel
    
    Parameters:
    count - number of elements to request from the server. Must be positive or zero. A value of zero is interpreted as the channel's native element count. If the specified number exceeds the channel's native element count, the monitor event will only provide the number of elements that is equal to the channel's native element count.
    
    Returns:
    monitor for this channel using the default event mask. The values supplied with monitor events can be expected to not exceed the specified number of elements.
  - monitorControlsLong
```
public ChannelAccessMonitor<ChannelAccessControlsLong> monitorControlsLong(int count,
                                                                  ChannelAccessEventMask eventMask)
```
    Description copied from interface: ChannelAccessChannel
    
    Creates a monitor for this channel using the DBR_CTRL_LONG data type, the specified element count, and the specified event mask.
    
    A monitor can be created for a channel that is currently disconnected (or has not yet been connected). However, the monitor will only post events when the channel is connected.
    
    Errors are typically indicated by calling the monitor listeners' monitorError(...) method. Only errors in the parameters to this method or a destroyed channel will result in an immediate exception thrown by this method.
    
    Specified by:
    
    monitorControlsLong in interface ChannelAccessChannel
    
    Parameters:
    count - number of elements to request from the server. Must be positive or zero. A value of zero is interpreted as the channel's native element count. If the specified number exceeds the channel's native element count, the monitor event will only provide the number of elements that is equal to the channel's native element count.
    eventMask - event mask to use for the monitor. The event mask specifies which events on the server will trigger a monitor event. If null, the default event mask is used.
    
    Returns:
    monitor for this channel using the specified event mask. The values supplied with monitor events can be expected to not exceed the specified number of elements.
  - monitorDouble
```
public ChannelAccessMonitor<ChannelAccessSimpleOnlyDouble> monitorDouble()
```
    Description copied from interface: ChannelAccessChannel
    
    Creates a monitor for this channel using the DBR_DOUBLE data type, the channel's native element count, and the default event mask. As a channel's native element count might vary over time, the number of elements in the values of monitor events might vary accordingly.
    
    A monitor can be created for a channel that is currently disconnected (or has not yet been connected). However, the monitor will only post events when the channel is connected.
    
    Errors are typically indicated by calling the monitor listeners' monitorError(...) method. Only a destroyed channel will result in an immediate exception thrown by this method.
    
    Specified by:
    
    monitorDouble in interface ChannelAccessChannel
    
    Returns:
    monitor for this channel using the default event mask.
  - monitorDouble
```
public ChannelAccessMonitor<ChannelAccessSimpleOnlyDouble> monitorDouble(ChannelAccessEventMask eventMask)
```
    Description copied from interface: ChannelAccessChannel
    
    Creates a monitor for this channel using the DBR_DOUBLE data type, the channel's native element count, and the specified event mask. As a channel's native element count might vary over time, the number of elements in the values of monitor events might vary accordingly.
    
    A monitor can be created for a channel that is currently disconnected (or has not yet been connected). However, the monitor will only post events when the channel is connected.
    
    Errors are typically indicated by calling the monitor listeners' monitorError(...) method. Only a destroyed channel will result in an immediate exception thrown by this method.
    
    Specified by:
    
    monitorDouble in interface ChannelAccessChannel
    
    Parameters:
    eventMask - event mask to use for the monitor. The event mask specifies which events on the server will trigger a monitor event. If null, the default event mask is used.
    
    Returns:
    monitor for this channel using the specified event mask.
  - monitorDouble
```
public ChannelAccessMonitor<ChannelAccessSimpleOnlyDouble> monitorDouble(int count)
```
    Description copied from interface: ChannelAccessChannel
    
    Creates a monitor for this channel using the DBR_DOUBLE data type, the specified element count, and the default event mask.
    
    A monitor can be created for a channel that is currently disconnected (or has not yet been connected). However, the monitor will only post events when the channel is connected.
    
    Errors are typically indicated by calling the monitor listeners' monitorError(...) method. Only errors in the parameters to this method or a destroyed channel will result in an immediate exception thrown by this method.
    
    Specified by:
    
    monitorDouble in interface ChannelAccessChannel
    
    Parameters:
    count - number of elements to request from the server. Must be positive or zero. A value of zero is interpreted as the channel's native element count. If the specified number exceeds the channel's native element count, the monitor event will only provide the number of elements that is equal to the channel's native element count.
    
    Returns:
    monitor for this channel using the default event mask. The values supplied with monitor events can be expected to not exceed the specified number of elements.
  - monitorDouble
```
public ChannelAccessMonitor<ChannelAccessSimpleOnlyDouble> monitorDouble(int count,
                                                                ChannelAccessEventMask eventMask)
```
    Description copied from interface: ChannelAccessChannel
    
    Creates a monitor for this channel using the DBR_DOUBLE data type, the specified element count, and the specified event mask.
    
    A monitor can be created for a channel that is currently disconnected (or has not yet been connected). However, the monitor will only post events when the channel is connected.
    
    Errors are typically indicated by calling the monitor listeners' monitorError(...) method. Only errors in the parameters to this method or a destroyed channel will result in an immediate exception thrown by this method.
    
    Specified by:
    
    monitorDouble in interface ChannelAccessChannel
    
    Parameters:
    count - number of elements to request from the server. Must be positive or zero. A value of zero is interpreted as the channel's native element count. If the specified number exceeds the channel's native element count, the monitor event will only provide the number of elements that is equal to the channel's native element count.
    eventMask - event mask to use for the monitor. The event mask specifies which events on the server will trigger a monitor event. If null, the default event mask is used.
    
    Returns:
    monitor for this channel using the specified event mask. The values supplied with monitor events can be expected to not exceed the specified number of elements.
  - monitorAlarmDouble
```
public ChannelAccessMonitor<ChannelAccessAlarmOnlyDouble> monitorAlarmDouble()
```
    Description copied from interface: ChannelAccessChannel
    
    Creates a monitor for this channel using the DBR_STS_DOUBLE data type, the channel's native element count, and the default event mask. As a channel's native element count might vary over time, the number of elements in the values of monitor events might vary accordingly.
    
    A monitor can be created for a channel that is currently disconnected (or has not yet been connected). However, the monitor will only post events when the channel is connected.
    
    Errors are typically indicated by calling the monitor listeners' monitorError(...) method. Only a destroyed channel will result in an immediate exception thrown by this method.
    
    Specified by:
    
    monitorAlarmDouble in interface ChannelAccessChannel
    
    Returns:
    monitor for this channel using the default event mask.
  - monitorAlarmDouble
```
public ChannelAccessMonitor<ChannelAccessAlarmOnlyDouble> monitorAlarmDouble(ChannelAccessEventMask eventMask)
```
    Description copied from interface: ChannelAccessChannel
    
    Creates a monitor for this channel using the DBR_STS_DOUBLE data type, the channel's native element count, and the specified event mask. As a channel's native element count might vary over time, the number of elements in the values of monitor events might vary accordingly.
    
    A monitor can be created for a channel that is currently disconnected (or has not yet been connected). However, the monitor will only post events when the channel is connected.
    
    Errors are typically indicated by calling the monitor listeners' monitorError(...) method. Only a destroyed channel will result in an immediate exception thrown by this method.
    
    Specified by:
    
    monitorAlarmDouble in interface ChannelAccessChannel
    
    Parameters:
    eventMask - event mask to use for the monitor. The event mask specifies which events on the server will trigger a monitor event. If null, the default event mask is used.
    
    Returns:
    monitor for this channel using the specified event mask.
  - monitorAlarmDouble
```
public ChannelAccessMonitor<ChannelAccessAlarmOnlyDouble> monitorAlarmDouble(int count)
```
    Description copied from interface: ChannelAccessChannel
    
    Creates a monitor for this channel using the DBR_STS_DOUBLE data type, the specified element count, and the default event mask.
    
    A monitor can be created for a channel that is currently disconnected (or has not yet been connected). However, the monitor will only post events when the channel is connected.
    
    Errors are typically indicated by calling the monitor listeners' monitorError(...) method. Only errors in the parameters to this method or a destroyed channel will result in an immediate exception thrown by this method.
    
    Specified by:
    
    monitorAlarmDouble in interface ChannelAccessChannel
    
    Parameters:
    count - number of elements to request from the server. Must be positive or zero. A value of zero is interpreted as the channel's native element count. If the specified number exceeds the channel's native element count, the monitor event will only provide the number of elements that is equal to the channel's native element count.
    
    Returns:
    monitor for this channel using the default event mask. The values supplied with monitor events can be expected to not exceed the specified number of elements.
  - monitorAlarmDouble
```
public ChannelAccessMonitor<ChannelAccessAlarmOnlyDouble> monitorAlarmDouble(int count,
                                                                    ChannelAccessEventMask eventMask)
```
    Description copied from interface: ChannelAccessChannel
    
    Creates a monitor for this channel using the DBR_STS_DOUBLE data type, the specified element count, and the specified event mask.
    
    A monitor can be created for a channel that is currently disconnected (or has not yet been connected). However, the monitor will only post events when the channel is connected.
    
    Errors are typically indicated by calling the monitor listeners' monitorError(...) method. Only errors in the parameters to this method or a destroyed channel will result in an immediate exception thrown by this method.
    
    Specified by:
    
    monitorAlarmDouble in interface ChannelAccessChannel
    
    Parameters:
    count - number of elements to request from the server. Must be positive or zero. A value of zero is interpreted as the channel's native element count. If the specified number exceeds the channel's native element count, the monitor event will only provide the number of elements that is equal to the channel's native element count.
    eventMask - event mask to use for the monitor. The event mask specifies which events on the server will trigger a monitor event. If null, the default event mask is used.
    
    Returns:
    monitor for this channel using the specified event mask. The values supplied with monitor events can be expected to not exceed the specified number of elements.
  - monitorTimeDouble
```
public ChannelAccessMonitor<ChannelAccessTimeDouble> monitorTimeDouble()
```
    Description copied from interface: ChannelAccessChannel
    
    Creates a monitor for this channel using the DBR_TIME_DOUBLE data type, the channel's native element count, and the default event mask. As a channel's native element count might vary over time, the number of elements in the values of monitor events might vary accordingly.
    
    A monitor can be created for a channel that is currently disconnected (or has not yet been connected). However, the monitor will only post events when the channel is connected.
    
    Errors are typically indicated by calling the monitor listeners' monitorError(...) method. Only a destroyed channel will result in an immediate exception thrown by this method.
    
    Specified by:
    
    monitorTimeDouble in interface ChannelAccessChannel
    
    Returns:
    monitor for this channel using the default event mask.
  - monitorTimeDouble
```
public ChannelAccessMonitor<ChannelAccessTimeDouble> monitorTimeDouble(ChannelAccessEventMask eventMask)
```
    Description copied from interface: ChannelAccessChannel
    
    Creates a monitor for this channel using the DBR_TIME_DOUBLE data type, the channel's native element count, and the specified event mask. As a channel's native element count might vary over time, the number of elements in the values of monitor events might vary accordingly.
    
    A monitor can be created for a channel that is currently disconnected (or has not yet been connected). However, the monitor will only post events when the channel is connected.
    
    Errors are typically indicated by calling the monitor listeners' monitorError(...) method. Only a destroyed channel will result in an immediate exception thrown by this method.
    
    Specified by:
    
    monitorTimeDouble in interface ChannelAccessChannel
    
    Parameters:
    eventMask - event mask to use for the monitor. The event mask specifies which events on the server will trigger a monitor event. If null, the default event mask is used.
    
    Returns:
    monitor for this channel using the specified event mask.
  - monitorTimeDouble
```
public ChannelAccessMonitor<ChannelAccessTimeDouble> monitorTimeDouble(int count)
```
    Description copied from interface: ChannelAccessChannel
    
    Creates a monitor for this channel using the DBR_TIME_DOUBLE data type, the specified element count, and the default event mask.
    
    A monitor can be created for a channel that is currently disconnected (or has not yet been connected). However, the monitor will only post events when the channel is connected.
    
    Errors are typically indicated by calling the monitor listeners' monitorError(...) method. Only errors in the parameters to this method or a destroyed channel will result in an immediate exception thrown by this method.
    
    Specified by:
    
    monitorTimeDouble in interface ChannelAccessChannel
    
    Parameters:
    count - number of elements to request from the server. Must be positive or zero. A value of zero is interpreted as the channel's native element count. If the specified number exceeds the channel's native element count, the monitor event will only provide the number of elements that is equal to the channel's native element count.
    
    Returns:
    monitor for this channel using the default event mask. The values supplied with monitor events can be expected to not exceed the specified number of elements.
  - monitorTimeDouble
```
public ChannelAccessMonitor<ChannelAccessTimeDouble> monitorTimeDouble(int count,
                                                              ChannelAccessEventMask eventMask)
```
    Description copied from interface: ChannelAccessChannel
    
    Creates a monitor for this channel using the DBR_TIME_DOUBLE data type, the specified element count, and the specified event mask.
    
    A monitor can be created for a channel that is currently disconnected (or has not yet been connected). However, the monitor will only post events when the channel is connected.
    
    Errors are typically indicated by calling the monitor listeners' monitorError(...) method. Only errors in the parameters to this method or a destroyed channel will result in an immediate exception thrown by this method.
    
    Specified by:
    
    monitorTimeDouble in interface ChannelAccessChannel
    
    Parameters:
    count - number of elements to request from the server. Must be positive or zero. A value of zero is interpreted as the channel's native element count. If the specified number exceeds the channel's native element count, the monitor event will only provide the number of elements that is equal to the channel's native element count.
    eventMask - event mask to use for the monitor. The event mask specifies which events on the server will trigger a monitor event. If null, the default event mask is used.
    
    Returns:
    monitor for this channel using the specified event mask. The values supplied with monitor events can be expected to not exceed the specified number of elements.
  - monitorGraphicsDouble
```
public ChannelAccessMonitor<ChannelAccessGraphicsOnlyDouble> monitorGraphicsDouble()
```
    Description copied from interface: ChannelAccessChannel
    
    Creates a monitor for this channel using the DBR_GR_DOUBLE data type, the channel's native element count, and the default event mask. As a channel's native element count might vary over time, the number of elements in the values of monitor events might vary accordingly.
    
    A monitor can be created for a channel that is currently disconnected (or has not yet been connected). However, the monitor will only post events when the channel is connected.
    
    Errors are typically indicated by calling the monitor listeners' monitorError(...) method. Only a destroyed channel will result in an immediate exception thrown by this method.
    
    Specified by:
    
    monitorGraphicsDouble in interface ChannelAccessChannel
    
    Returns:
    monitor for this channel using the default event mask.
  - monitorGraphicsDouble
```
public ChannelAccessMonitor<ChannelAccessGraphicsOnlyDouble> monitorGraphicsDouble(ChannelAccessEventMask eventMask)
```
    Description copied from interface: ChannelAccessChannel
    
    Creates a monitor for this channel using the DBR_GR_DOUBLE data type, the channel's native element count, and the specified event mask. As a channel's native element count might vary over time, the number of elements in the values of monitor events might vary accordingly.
    
    A monitor can be created for a channel that is currently disconnected (or has not yet been connected). However, the monitor will only post events when the channel is connected.
    
    Errors are typically indicated by calling the monitor listeners' monitorError(...) method. Only a destroyed channel will result in an immediate exception thrown by this method.
    
    Specified by:
    
    monitorGraphicsDouble in interface ChannelAccessChannel
    
    Parameters:
    eventMask - event mask to use for the monitor. The event mask specifies which events on the server will trigger a monitor event. If null, the default event mask is used.
    
    Returns:
    monitor for this channel using the specified event mask.
  - monitorGraphicsDouble
```
public ChannelAccessMonitor<ChannelAccessGraphicsOnlyDouble> monitorGraphicsDouble(int count)
```
    Description copied from interface: ChannelAccessChannel
    
    Creates a monitor for this channel using the DBR_GR_DOUBLE data type, the specified element count, and the default event mask.
    
    A monitor can be created for a channel that is currently disconnected (or has not yet been connected). However, the monitor will only post events when the channel is connected.
    
    Errors are typically indicated by calling the monitor listeners' monitorError(...) method. Only errors in the parameters to this method or a destroyed channel will result in an immediate exception thrown by this method.
    
    Specified by:
    
    monitorGraphicsDouble in interface ChannelAccessChannel
    
    Parameters:
    count - number of elements to request from the server. Must be positive or zero. A value of zero is interpreted as the channel's native element count. If the specified number exceeds the channel's native element count, the monitor event will only provide the number of elements that is equal to the channel's native element count.
    
    Returns:
    monitor for this channel using the default event mask. The values supplied with monitor events can be expected to not exceed the specified number of elements.
  - monitorGraphicsDouble
```
public ChannelAccessMonitor<ChannelAccessGraphicsOnlyDouble> monitorGraphicsDouble(int count,
                                                                          ChannelAccessEventMask eventMask)
```
    Description copied from interface: ChannelAccessChannel
    
    Creates a monitor for this channel using the DBR_GR_DOUBLE data type, the specified element count, and the specified event mask.
    
    A monitor can be created for a channel that is currently disconnected (or has not yet been connected). However, the monitor will only post events when the channel is connected.
    
    Errors are typically indicated by calling the monitor listeners' monitorError(...) method. Only errors in the parameters to this method or a destroyed channel will result in an immediate exception thrown by this method.
    
    Specified by:
    
    monitorGraphicsDouble in interface ChannelAccessChannel
    
    Parameters:
    count - number of elements to request from the server. Must be positive or zero. A value of zero is interpreted as the channel's native element count. If the specified number exceeds the channel's native element count, the monitor event will only provide the number of elements that is equal to the channel's native element count.
    eventMask - event mask to use for the monitor. The event mask specifies which events on the server will trigger a monitor event. If null, the default event mask is used.
    
    Returns:
    monitor for this channel using the specified event mask. The values supplied with monitor events can be expected to not exceed the specified number of elements.
  - monitorControlsDouble
```
public ChannelAccessMonitor<ChannelAccessControlsDouble> monitorControlsDouble()
```
    Description copied from interface: ChannelAccessChannel
    
    Creates a monitor for this channel using the DBR_CTRL_DOUBLE data type, the channel's native element count, and the default event mask. As a channel's native element count might vary over time, the number of elements in the values of monitor events might vary accordingly.
    
    A monitor can be created for a channel that is currently disconnected (or has not yet been connected). However, the monitor will only post events when the channel is connected.
    
    Errors are typically indicated by calling the monitor listeners' monitorError(...) method. Only a destroyed channel will result in an immediate exception thrown by this method.
    
    Specified by:
    
    monitorControlsDouble in interface ChannelAccessChannel
    
    Returns:
    monitor for this channel using the default event mask.
  - monitorControlsDouble
```
public ChannelAccessMonitor<ChannelAccessControlsDouble> monitorControlsDouble(ChannelAccessEventMask eventMask)
```
    Description copied from interface: ChannelAccessChannel
    
    Creates a monitor for this channel using the DBR_CTRL_DOUBLE data type, the channel's native element count, and the specified event mask. As a channel's native element count might vary over time, the number of elements in the values of monitor events might vary accordingly.
    
    A monitor can be created for a channel that is currently disconnected (or has not yet been connected). However, the monitor will only post events when the channel is connected.
    
    Errors are typically indicated by calling the monitor listeners' monitorError(...) method. Only a destroyed channel will result in an immediate exception thrown by this method.
    
    Specified by:
    
    monitorControlsDouble in interface ChannelAccessChannel
    
    Parameters:
    eventMask - event mask to use for the monitor. The event mask specifies which events on the server will trigger a monitor event. If null, the default event mask is used.
    
    Returns:
    monitor for this channel using the specified event mask.
  - monitorControlsDouble
```
public ChannelAccessMonitor<ChannelAccessControlsDouble> monitorControlsDouble(int count)
```
    Description copied from interface: ChannelAccessChannel
    
    Creates a monitor for this channel using the DBR_CTRL_DOUBLE data type, the specified element count, and the default event mask.
    
    A monitor can be created for a channel that is currently disconnected (or has not yet been connected). However, the monitor will only post events when the channel is connected.
    
    Errors are typically indicated by calling the monitor listeners' monitorError(...) method. Only errors in the parameters to this method or a destroyed channel will result in an immediate exception thrown by this method.
    
    Specified by:
    
    monitorControlsDouble in interface ChannelAccessChannel
    
    Parameters:
    count - number of elements to request from the server. Must be positive or zero. A value of zero is interpreted as the channel's native element count. If the specified number exceeds the channel's native element count, the monitor event will only provide the number of elements that is equal to the channel's native element count.
    
    Returns:
    monitor for this channel using the default event mask. The values supplied with monitor events can be expected to not exceed the specified number of elements.
  - monitorControlsDouble
```
public ChannelAccessMonitor<ChannelAccessControlsDouble> monitorControlsDouble(int count,
                                                                      ChannelAccessEventMask eventMask)
```
    Description copied from interface: ChannelAccessChannel
    
    Creates a monitor for this channel using the DBR_CTRL_DOUBLE data type, the specified element count, and the specified event mask.
    
    A monitor can be created for a channel that is currently disconnected (or has not yet been connected). However, the monitor will only post events when the channel is connected.
    
    Errors are typically indicated by calling the monitor listeners' monitorError(...) method. Only errors in the parameters to this method or a destroyed channel will result in an immediate exception thrown by this method.
    
    Specified by:
    
    monitorControlsDouble in interface ChannelAccessChannel
    
    Parameters:
    count - number of elements to request from the server. Must be positive or zero. A value of zero is interpreted as the channel's native element count. If the specified number exceeds the channel's native element count, the monitor event will only provide the number of elements that is equal to the channel's native element count.
    eventMask - event mask to use for the monitor. The event mask specifies which events on the server will trigger a monitor event. If null, the default event mask is used.
    
    Returns:
    monitor for this channel using the specified event mask. The values supplied with monitor events can be expected to not exceed the specified number of elements.
  - monitorAlarmAcknowledgementStatus
```
public ChannelAccessMonitor<ChannelAccessAlarmAcknowledgementStatus> monitorAlarmAcknowledgementStatus()
```
    Description copied from interface: ChannelAccessChannel
    
    Creates a monitor for this channel using the DBR_STSACK_STRING data type, the channel's native element count, and the default event mask. As a channel's native element count might vary over time, the number of elements in the values of monitor events might vary accordingly.
    
    A monitor can be created for a channel that is currently disconnected (or has not yet been connected). However, the monitor will only post events when the channel is connected.
    
    Errors are typically indicated by calling the monitor listeners' monitorError(...) method. Only a destroyed channel will result in an immediate exception thrown by this method.
    
    Specified by:
    
    monitorAlarmAcknowledgementStatus in interface ChannelAccessChannel
    
    Returns:
    monitor for this channel using the default event mask.
  - monitorAlarmAcknowledgementStatus
```
public ChannelAccessMonitor<ChannelAccessAlarmAcknowledgementStatus> monitorAlarmAcknowledgementStatus(ChannelAccessEventMask eventMask)
```
    Description copied from interface: ChannelAccessChannel
    
    Creates a monitor for this channel using the DBR_STSACK_STRING data type, the channel's native element count, and the specified event mask. As a channel's native element count might vary over time, the number of elements in the values of monitor events might vary accordingly.
    
    A monitor can be created for a channel that is currently disconnected (or has not yet been connected). However, the monitor will only post events when the channel is connected.
    
    Errors are typically indicated by calling the monitor listeners' monitorError(...) method. Only a destroyed channel will result in an immediate exception thrown by this method.
    
    Specified by:
    
    monitorAlarmAcknowledgementStatus in interface ChannelAccessChannel
    
    Parameters:
    eventMask - event mask to use for the monitor. The event mask specifies which events on the server will trigger a monitor event. If null, the default event mask is used.
    
    Returns:
    monitor for this channel using the specified event mask.
  - monitorAlarmAcknowledgementStatus
```
public ChannelAccessMonitor<ChannelAccessAlarmAcknowledgementStatus> monitorAlarmAcknowledgementStatus(int count)
```
    Description copied from interface: ChannelAccessChannel
    
    Creates a monitor for this channel using the DBR_STSACK_STRING data type, the specified element count, and the default event mask.
    
    A monitor can be created for a channel that is currently disconnected (or has not yet been connected). However, the monitor will only post events when the channel is connected.
    
    Errors are typically indicated by calling the monitor listeners' monitorError(...) method. Only errors in the parameters to this method or a destroyed channel will result in an immediate exception thrown by this method.
    
    Specified by:
    
    monitorAlarmAcknowledgementStatus in interface ChannelAccessChannel
    
    Parameters:
    count - number of elements to request from the server. Must be positive or zero. A value of zero is interpreted as the channel's native element count. If the specified number exceeds the channel's native element count, the monitor event will only provide the number of elements that is equal to the channel's native element count.
    
    Returns:
    monitor for this channel using the default event mask. The values supplied with monitor events can be expected to not exceed the specified number of elements.
  - monitorAlarmAcknowledgementStatus
```
public ChannelAccessMonitor<ChannelAccessAlarmAcknowledgementStatus> monitorAlarmAcknowledgementStatus(int count,
                                                                                              ChannelAccessEventMask eventMask)
```
    Description copied from interface: ChannelAccessChannel
    
    Creates a monitor for this channel using the DBR_STSACK_STRING data type, the specified element count, and the specified event mask.
    
    A monitor can be created for a channel that is currently disconnected (or has not yet been connected). However, the monitor will only post events when the channel is connected.
    
    Errors are typically indicated by calling the monitor listeners' monitorError(...) method. Only errors in the parameters to this method or a destroyed channel will result in an immediate exception thrown by this method.
    
    Specified by:
    
    monitorAlarmAcknowledgementStatus in interface ChannelAccessChannel
    
    Parameters:
    count - number of elements to request from the server. Must be positive or zero. A value of zero is interpreted as the channel's native element count. If the specified number exceeds the channel's native element count, the monitor event will only provide the number of elements that is equal to the channel's native element count.
    eventMask - event mask to use for the monitor. The event mask specifies which events on the server will trigger a monitor event. If null, the default event mask is used.
    
    Returns:
    monitor for this channel using the specified event mask. The values supplied with monitor events can be expected to not exceed the specified number of elements.
  - monitorClassName
```
public ChannelAccessMonitor<ChannelAccessClassName> monitorClassName()
```
    Description copied from interface: ChannelAccessChannel
    
    Creates a monitor for this channel using the DBR_CLASS_NAME data type, the channel's native element count, and the default event mask. As a channel's native element count might vary over time, the number of elements in the values of monitor events might vary accordingly.
    
    A monitor can be created for a channel that is currently disconnected (or has not yet been connected). However, the monitor will only post events when the channel is connected.
    
    Errors are typically indicated by calling the monitor listeners' monitorError(...) method. Only a destroyed channel will result in an immediate exception thrown by this method.
    
    Specified by:
    
    monitorClassName in interface ChannelAccessChannel
    
    Returns:
    monitor for this channel using the default event mask.
  - monitorClassName
```
public ChannelAccessMonitor<ChannelAccessClassName> monitorClassName(ChannelAccessEventMask eventMask)
```
    Description copied from interface: ChannelAccessChannel
    
    Creates a monitor for this channel using the DBR_CLASS_NAME data type, the channel's native element count, and the specified event mask. As a channel's native element count might vary over time, the number of elements in the values of monitor events might vary accordingly.
    
    A monitor can be created for a channel that is currently disconnected (or has not yet been connected). However, the monitor will only post events when the channel is connected.
    
    Errors are typically indicated by calling the monitor listeners' monitorError(...) method. Only a destroyed channel will result in an immediate exception thrown by this method.
    
    Specified by:
    
    monitorClassName in interface ChannelAccessChannel
    
    Parameters:
    eventMask - event mask to use for the monitor. The event mask specifies which events on the server will trigger a monitor event. If null, the default event mask is used.
    
    Returns:
    monitor for this channel using the specified event mask.
  - monitorClassName
```
public ChannelAccessMonitor<ChannelAccessClassName> monitorClassName(int count)
```
    Description copied from interface: ChannelAccessChannel
    
    Creates a monitor for this channel using the DBR_CLASS_NAME data type, the specified element count, and the default event mask.
    
    A monitor can be created for a channel that is currently disconnected (or has not yet been connected). However, the monitor will only post events when the channel is connected.
    
    Errors are typically indicated by calling the monitor listeners' monitorError(...) method. Only errors in the parameters to this method or a destroyed channel will result in an immediate exception thrown by this method.
    
    Specified by:
    
    monitorClassName in interface ChannelAccessChannel
    
    Parameters:
    count - number of elements to request from the server. Must be positive or zero. A value of zero is interpreted as the channel's native element count. If the specified number exceeds the channel's native element count, the monitor event will only provide the number of elements that is equal to the channel's native element count.
    
    Returns:
    monitor for this channel using the default event mask. The values supplied with monitor events can be expected to not exceed the specified number of elements.
  - monitorClassName
```
public ChannelAccessMonitor<ChannelAccessClassName> monitorClassName(int count,
                                                            ChannelAccessEventMask eventMask)
```
    Description copied from interface: ChannelAccessChannel
    
    Creates a monitor for this channel using the DBR_CLASS_NAME data type, the specified element count, and the specified event mask.
    
    A monitor can be created for a channel that is currently disconnected (or has not yet been connected). However, the monitor will only post events when the channel is connected.
    
    Errors are typically indicated by calling the monitor listeners' monitorError(...) method. Only errors in the parameters to this method or a destroyed channel will result in an immediate exception thrown by this method.
    
    Specified by:
    
    monitorClassName in interface ChannelAccessChannel
    
    Parameters:
    count - number of elements to request from the server. Must be positive or zero. A value of zero is interpreted as the channel's native element count. If the specified number exceeds the channel's native element count, the monitor event will only provide the number of elements that is equal to the channel's native element count.
    eventMask - event mask to use for the monitor. The event mask specifies which events on the server will trigger a monitor event. If null, the default event mask is used.
    
    Returns:
    monitor for this channel using the specified event mask. The values supplied with monitor events can be expected to not exceed the specified number of elements.
  - putString
```
public ListenableFuture<Void> putString(String value)
```
    Description copied from interface: ChannelAccessChannel
    
    Puts the specified single element DBR_STRING to the channel.
    
    Due to a put operation's asynchronous nature, this method does not block, but a future that can be used to wait on the operation and to get an error (if there is any) is returned.
    
    Errors are typically indicated by an exception that is wrapped in an ExecutionException that is thrown by the future. Only errors in the parameters to this method or a destroyed channel will result in an immediate exception thrown by this method.
    
    Specified by:
    
    putString in interface ChannelAccessChannel
    
    Parameters:
    value - value written to the channel.
    
    Returns:
    listenable future that can be used to retrieve the result of the operation and to be notified when the operation finishes.
  - putString
```
public ListenableFuture<Void> putString(String[] value)
```
    Description copied from interface: ChannelAccessChannel
    
    Puts the specified array to the channel as a DBR_STRING. Specifying an array that is larger than the channel's native element count might result in an error. However, most servers will simply ignore the extra element's and only use the beginning of the array. The specified arrays is copied, so subsequent changes to the collection will not have any effect on the put operation.
    
    Due to a put operation's asynchronous nature, this method does not block, but a future that can be used to wait on the operation and to get an error (if there is any) is returned.
    
    Errors are typically indicated by an exception that is wrapped in an ExecutionException that is thrown by the future. Only errors in the parameters to this method or a destroyed channel will result in an immediate exception thrown by this method.
    
    Specified by:
    
    putString in interface ChannelAccessChannel
    
    Parameters:
    value - value written to the channel.
    
    Returns:
    listenable future that can be used to retrieve the result of the operation and to be notified when the operation finishes.
  - putString
```
public ListenableFuture<Void> putString(Collection<String> value)
```
    Description copied from interface: ChannelAccessChannel
    
    Puts the specified collection to the channel as a DBR_STRING. Specifying a collection that is larger than the channel's native element count might result in an error. However, most servers will simply ignore the extra element's and only use the beginning of the array. The specified collection is copied, so subsequent changes to the collection will not have any effect on the put operation.
    
    Due to a put operation's asynchronous nature, this method does not block, but a future that can be used to wait on the operation and to get an error (if there is any) is returned.
    
    Errors are typically indicated by an exception that is wrapped in an ExecutionException that is thrown by the future. Only errors in the parameters to this method or a destroyed channel will result in an immediate exception thrown by this method.
    
    Specified by:
    
    putString in interface ChannelAccessChannel
    
    Parameters:
    value - value written to the channel.
    
    Returns:
    listenable future that can be used to retrieve the result of the operation and to be notified when the operation finishes.
  - putShort
```
public ListenableFuture<Void> putShort(short value)
```
    Description copied from interface: ChannelAccessChannel
    
    Puts the specified single element DBR_SHORT to the channel.
    
    Due to a put operation's asynchronous nature, this method does not block, but a future that can be used to wait on the operation and to get an error (if there is any) is returned.
    
    Errors are typically indicated by an exception that is wrapped in an ExecutionException that is thrown by the future. Only a destroyed channel will result in an immediate exception thrown by this method.
    
    Specified by:
    
    putShort in interface ChannelAccessChannel
    
    Parameters:
    value - value written to the channel.
    
    Returns:
    listenable future that can be used to retrieve the result of the operation and to be notified when the operation finishes.
  - putShort
```
public ListenableFuture<Void> putShort(short[] value)
```
    Description copied from interface: ChannelAccessChannel
    
    Puts the specified array to the channel as a DBR_SHORT. Specifying an array that is larger than the channel's native element count might result in an error. However, most servers will simply ignore the extra element's and only use the beginning of the array. The specified arrays is not copied, so the calling code should not make any changes to the array after passing it to this method.
    
    Due to a put operation's asynchronous nature, this method does not block, but a future that can be used to wait on the operation and to get an error (if there is any) is returned.
    
    Errors are typically indicated by an exception that is wrapped in an ExecutionException that is thrown by the future. Only errors in the parameters to this method or a destroyed channel will result in an immediate exception thrown by this method.
    
    Specified by:
    
    putShort in interface ChannelAccessChannel
    
    Parameters:
    value - value written to the channel.
    
    Returns:
    listenable future that can be used to retrieve the result of the operation and to be notified when the operation finishes.
  - putFloat
```
public ListenableFuture<Void> putFloat(float value)
```
    Description copied from interface: ChannelAccessChannel
    
    Puts the specified single element DBR_FLOAT to the channel.
    
    Due to a put operation's asynchronous nature, this method does not block, but a future that can be used to wait on the operation and to get an error (if there is any) is returned.
    
    Errors are typically indicated by an exception that is wrapped in an ExecutionException that is thrown by the future. Only a destroyed channel will result in an immediate exception thrown by this method.
    
    Specified by:
    
    putFloat in interface ChannelAccessChannel
    
    Parameters:
    value - value written to the channel.
    
    Returns:
    listenable future that can be used to retrieve the result of the operation and to be notified when the operation finishes.
  - putFloat
```
public ListenableFuture<Void> putFloat(float[] value)
```
    Description copied from interface: ChannelAccessChannel
    
    Puts the specified array to the channel as a DBR_FLOAT. Specifying an array that is larger than the channel's native element count might result in an error. However, most servers will simply ignore the extra element's and only use the beginning of the array. The specified arrays is not copied, so the calling code should not make any changes to the array after passing it to this method.
    
    Due to a put operation's asynchronous nature, this method does not block, but a future that can be used to wait on the operation and to get an error (if there is any) is returned.
    
    Errors are typically indicated by an exception that is wrapped in an ExecutionException that is thrown by the future. Only errors in the parameters to this method or a destroyed channel will result in an immediate exception thrown by this method.
    
    Specified by:
    
    putFloat in interface ChannelAccessChannel
    
    Parameters:
    value - value written to the channel.
    
    Returns:
    listenable future that can be used to retrieve the result of the operation and to be notified when the operation finishes.
  - putEnum
```
public ListenableFuture<Void> putEnum(short value)
```
    Description copied from interface: ChannelAccessChannel
    
    Puts the specified single element DBR_ENUM to the channel.
    
    Due to a put operation's asynchronous nature, this method does not block, but a future that can be used to wait on the operation and to get an error (if there is any) is returned.
    
    Errors are typically indicated by an exception that is wrapped in an ExecutionException that is thrown by the future. Only a destroyed channel will result in an immediate exception thrown by this method.
    
    Specified by:
    
    putEnum in interface ChannelAccessChannel
    
    Parameters:
    value - value written to the channel.
    
    Returns:
    listenable future that can be used to retrieve the result of the operation and to be notified when the operation finishes.
  - putEnum
```
public ListenableFuture<Void> putEnum(short[] value)
```
    Description copied from interface: ChannelAccessChannel
    
    Puts the specified array to the channel as a DBR_ENUM. Specifying an array that is larger than the channel's native element count might result in an error. However, most servers will simply ignore the extra element's and only use the beginning of the array. The specified arrays is not copied, so the calling code should not make any changes to the array after passing it to this method.
    
    Due to a put operation's asynchronous nature, this method does not block, but a future that can be used to wait on the operation and to get an error (if there is any) is returned.
    
    Errors are typically indicated by an exception that is wrapped in an ExecutionException that is thrown by the future. Only errors in the parameters to this method or a destroyed channel will result in an immediate exception thrown by this method.
    
    Specified by:
    
    putEnum in interface ChannelAccessChannel
    
    Parameters:
    value - value written to the channel.
    
    Returns:
    listenable future that can be used to retrieve the result of the operation and to be notified when the operation finishes.
  - putChar
```
public ListenableFuture<Void> putChar(byte value)
```
    Description copied from interface: ChannelAccessChannel
    
    Puts the specified single element DBR_CHAR to the channel.
    
    Due to a put operation's asynchronous nature, this method does not block, but a future that can be used to wait on the operation and to get an error (if there is any) is returned.
    
    Errors are typically indicated by an exception that is wrapped in an ExecutionException that is thrown by the future. Only a destroyed channel will result in an immediate exception thrown by this method.
    
    Specified by:
    
    putChar in interface ChannelAccessChannel
    
    Parameters:
    value - value written to the channel.
    
    Returns:
    listenable future that can be used to retrieve the result of the operation and to be notified when the operation finishes.
  - putChar
```
public ListenableFuture<Void> putChar(byte[] value)
```
    Description copied from interface: ChannelAccessChannel
    
    Puts the specified array to the channel as a DBR_CHAR. Specifying an array that is larger than the channel's native element count might result in an error. However, most servers will simply ignore the extra element's and only use the beginning of the array. The specified arrays is not copied, so the calling code should not make any changes to the array after passing it to this method.
    
    Due to a put operation's asynchronous nature, this method does not block, but a future that can be used to wait on the operation and to get an error (if there is any) is returned.
    
    Errors are typically indicated by an exception that is wrapped in an ExecutionException that is thrown by the future. Only errors in the parameters to this method or a destroyed channel will result in an immediate exception thrown by this method.
    
    Specified by:
    
    putChar in interface ChannelAccessChannel
    
    Parameters:
    value - value written to the channel.
    
    Returns:
    listenable future that can be used to retrieve the result of the operation and to be notified when the operation finishes.
  - putLong
```
public ListenableFuture<Void> putLong(int value)
```
    Description copied from interface: ChannelAccessChannel
    
    Puts the specified single element DBR_LONG to the channel.
    
    Due to a put operation's asynchronous nature, this method does not block, but a future that can be used to wait on the operation and to get an error (if there is any) is returned.
    
    Errors are typically indicated by an exception that is wrapped in an ExecutionException that is thrown by the future. Only a destroyed channel will result in an immediate exception thrown by this method.
    
    Specified by:
    
    putLong in interface ChannelAccessChannel
    
    Parameters:
    value - value written to the channel.
    
    Returns:
    listenable future that can be used to retrieve the result of the operation and to be notified when the operation finishes.
  - putLong
```
public ListenableFuture<Void> putLong(int[] value)
```
    Description copied from interface: ChannelAccessChannel
    
    Puts the specified array to the channel as a DBR_LONG. Specifying an array that is larger than the channel's native element count might result in an error. However, most servers will simply ignore the extra element's and only use the beginning of the array. The specified arrays is not copied, so the calling code should not make any changes to the array after passing it to this method.
    
    Due to a put operation's asynchronous nature, this method does not block, but a future that can be used to wait on the operation and to get an error (if there is any) is returned.
    
    Errors are typically indicated by an exception that is wrapped in an ExecutionException that is thrown by the future. Only errors in the parameters to this method or a destroyed channel will result in an immediate exception thrown by this method.
    
    Specified by:
    
    putLong in interface ChannelAccessChannel
    
    Parameters:
    value - value written to the channel.
    
    Returns:
    listenable future that can be used to retrieve the result of the operation and to be notified when the operation finishes.
  - putDouble
```
public ListenableFuture<Void> putDouble(double value)
```
    Description copied from interface: ChannelAccessChannel
    
    Puts the specified single element DBR_DOUBLE to the channel.
    
    Due to a put operation's asynchronous nature, this method does not block, but a future that can be used to wait on the operation and to get an error (if there is any) is returned.
    
    Errors are typically indicated by an exception that is wrapped in an ExecutionException that is thrown by the future. Only a destroyed channel will result in an immediate exception thrown by this method.
    
    Specified by:
    
    putDouble in interface ChannelAccessChannel
    
    Parameters:
    value - value written to the channel.
    
    Returns:
    listenable future that can be used to retrieve the result of the operation and to be notified when the operation finishes.
  - putDouble
```
public ListenableFuture<Void> putDouble(double[] value)
```
    Description copied from interface: ChannelAccessChannel
    
    Puts the specified array to the channel as a DBR_DOUBLE. Specifying an array that is larger than the channel's native element count might result in an error. However, most servers will simply ignore the extra element's and only use the beginning of the array. The specified arrays is not copied, so the calling code should not make any changes to the array after passing it to this method.
    
    Due to a put operation's asynchronous nature, this method does not block, but a future that can be used to wait on the operation and to get an error (if there is any) is returned.
    
    Errors are typically indicated by an exception that is wrapped in an ExecutionException that is thrown by the future. Only errors in the parameters to this method or a destroyed channel will result in an immediate exception thrown by this method.
    
    Specified by:
    
    putDouble in interface ChannelAccessChannel
    
    Parameters:
    value - value written to the channel.
    
    Returns:
    listenable future that can be used to retrieve the result of the operation and to be notified when the operation finishes.
  - putConfigureAcknowledgeTransientAlarms
```
public ListenableFuture<Void> putConfigureAcknowledgeTransientAlarms(boolean explicitlyAcknowledgeTransientAlarms)
```
    Description copied from interface: ChannelAccessChannel
    
    Puts the specified DBR_PUT_ACKT to the channel. This can be used to configure the transient alarm setting of the channel.
    
    Due to a put operation's asynchronous nature, this method does not block, but a future that can be used to wait on the operation and to get an error (if there is any) is returned.
    
    Errors are typically indicated by an exception that is wrapped in an ExecutionException that is thrown by the future. Only a destroyed channel will result in an immediate exception thrown by this method.
    
    Specified by:
    
    putConfigureAcknowledgeTransientAlarms in interface ChannelAccessChannel
    
    Parameters:
    explicitlyAcknowledgeTransientAlarms - true if transient alarms should have to be acknowledged explicitly, false if they should be automatically acknowledged when they disappear.
    
    Returns:
    listenable future that can be used to retrieve the result of the operation and to be notified when the operation finishes.
  - putAcknowledgeAlarm
```
public ListenableFuture<Void> putAcknowledgeAlarm(ChannelAccessAlarmSeverity acknowledgeAlarmSeverity)
```
    Description copied from interface: ChannelAccessChannel
    
    Puts the specified DBR_PUT_ACKS to the channel. This can be used to acknowledge alarms for the channel.
    
    Due to a put operation's asynchronous nature, this method does not block, but a future that can be used to wait on the operation and to get an error (if there is any) is returned.
    
    Errors are typically indicated by an exception that is wrapped in an ExecutionException that is thrown by the future. Only a destroyed channel will result in an immediate exception thrown by this method.
    
    Specified by:
    
    putAcknowledgeAlarm in interface ChannelAccessChannel
    
    Parameters:
    acknowledgeAlarmSeverity - highest alarm severity that should be acknowledged (never null). This means that the alarm will be acknowledged if the severity of the unacknowledged alarm is less than or equal to the specified severity.
    
    Returns:
    listenable future that can be used to retrieve the result of the operation and to be notified when the operation finishes.

Class AbstractChannelAccessChannel

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Methods inherited from interface com.aquenos.epics.jackie.client.ChannelAccessChannel

Field Detail

connectionStateLock

Constructor Detail

AbstractChannelAccessChannel

Method Detail

updateConnectionState

notifyConnectionListener

notifyWaitForConnectionStateFutureListener

isConnected

isConnectedOnce

addConnectionListener

removeConnectionListener

waitForConnectionState

get

getNative

getNative

getString

getString

getAlarmString

getAlarmString

getTimeString

getTimeString

getGraphicsString

getGraphicsString

getControlsString

getControlsString

getShort

getShort

getAlarmShort

getAlarmShort

getTimeShort

getTimeShort

getGraphicsShort

getGraphicsShort

getControlsShort

getControlsShort

getFloat

getFloat

getAlarmFloat

getAlarmFloat

getTimeFloat

getTimeFloat

getGraphicsFloat

getGraphicsFloat

getControlsFloat

getControlsFloat

getEnum

getEnum

getAlarmEnum

getAlarmEnum

getTimeEnum

getTimeEnum

getGraphicsEnum

getGraphicsEnum

getControlsEnum

getControlsEnum

getChar

getChar

getAlarmChar

getAlarmChar

getTimeChar

getTimeChar

getGraphicsChar

getGraphicsChar

getControlsChar

getControlsChar

getLong

getLong

getAlarmLong

getAlarmLong

getTimeLong

getTimeLong

getGraphicsLong

getGraphicsLong