AbstractDriver

java.lang.Object
- com.inductiveautomation.xopc.driver.api.AbstractDriver<M>

All Implemented Interfaces:

Driver, DriverTagManager

Direct Known Subclasses:

AbstractIODelegatingDriver, AbstractSocketDriver, NodeMapDriver
```
public abstract class AbstractDriver<M>
extends java.lang.Object
implements Driver, DriverTagManager
```
A partial implementation of Driver that handles the complexities of maintaining a subscription model, a request schedule, managing a request cycle, and the DriverState.
Implementations then need only worry about how to optimize and create Request's for reading, writing, and browsing as well as handling calls to connect and disconnect.

Field Summary

Fields
Modifier and Type	Field and Description
`protected NodeBuilderFactory`	`builderFactory`
`protected DriverDiagnosticsImpl`	`diagnosticsContext`
`protected java.util.concurrent.ScheduledExecutorService`	`executor`
`protected LoggerEx`	`log`
`protected NodeManager`	`nodeManager`

Constructor Summary

Constructors
Constructor and Description

AbstractDriver(DriverContext driverContext)

Constructors
Constructor and Description
`AbstractDriver(DriverContext driverContext)`

Method Summary

All Methods Instance Methods Abstract Methods Concrete Methods
Modifier and Type	Method and Description
`void`	`addDriverTag(DriverTag tag)` Add a `DriverTag`.
`void`	`browse(BrowseOperation browseOp)` Asynchronous browse operation.
`protected abstract void`	`connect()` A chance for implementations to do anything that is needed before moving into `DriverState.Connected`.
`protected abstract Request<M>`	`createBrowseRequest(BrowseOperation browseOp)` Create a browse `Request` for the given `BrowseOperation`.
`protected abstract Request<M>`	`createReadRequest(java.util.List<? extends ReadItem> items)` Create a read `Request` with the given items.
`protected Request<M>`	`createSubscribeRequest(java.util.List<? extends ReadItem> items)` Create a read `Request` with the given items.
`protected abstract Request<M>`	`createWriteRequest(java.util.List<? extends WriteItem> items)` Create a write `Request` with the given items.
`Guid`	`currentGuid()`
`protected abstract void`	`disconnect()` A chance for implementations to do anything that is needed before moving into `DriverState.Disconnected`.
`DriverTag`	`findTag(java.lang.String address)` Find a `DriverTag` with the given address, if it exists.
`int`	`getConcurrentRequests()`
`DriverDiagnostics`	`getDiagnostics()`
`DriverContext`	`getDriverContext()`
`java.util.Optional<DriverMetrics>`	`getDriverMetrics()` If this driver uses a traditional polling model, a `DriverMetrics`.
`DriverState`	`getDriverState()`
`java.lang.String`	`getDriverStatus()` Returns the current status of the driver.
`java.lang.String`	`getDriverTagAddressPrefix()`
`LoggerEx`	`getLogger()`
`java.lang.String`	`getName()`
`RequestDiagnostics`	`getRequestDiagnostics(java.lang.String address)`
`protected abstract java.lang.Object`	`getRequestKey(M message)` Extract the request key from the given message.
`protected abstract boolean`	`isBrowsingSupported()`
`protected abstract boolean`	`isOfflineBrowsingSupported()`
`protected void`	`messageArrived(M message)` Notify `AbstractDriver` that a messaged arrived.
`Guid`	`nextGuid()`
`void`	`notifyConnectFailed(java.lang.Exception connectError)` Callback indicating that the result of `connect()` was a failure.
`void`	`notifyConnectionLost()` Notify `AbstractDriver` that the connection has unintentionally been lost.
`void`	`notifyConnectSucceeded()` Callback indicating that the result of `connect()` was a success.
`void`	`notifyDisconnectDone()` A callback to notify `AbstractDriver` that a call to `disconnect()` is done.
`protected abstract java.util.List<java.util.List<? extends ReadItem>>`	`optimizeRead(java.util.List<? extends ReadItem> items)` Optimize the given list of items into sub-lists, where each sub-list is expected to fit into a single `Request` when `createReadRequest(List)` is called.
`protected java.util.List<java.util.List<? extends ReadItem>>`	`optimizeSubscribe(java.util.List<? extends ReadItem> items)` Optimize the given list of items into sub-lists, where each sub-list is expected to fit into a single `Request` when `createSubscribeRequest(List)` is called.
`protected java.util.List<java.util.List<? extends WriteItem>>`	`optimizeWrite(java.util.List<? extends WriteItem> items)` Optimize the given list of items into sub-lists where each sub-list is expected to fit into a single Request when `createWriteRequest(List)` is called.
`void`	`postRequest(Request<M> request, int delay)` Post a `Request`.
`void`	`readItems(java.util.List<? extends ReadItem> items)` Asynchronous read call for a list of items.
`void`	`removeDriverTag(java.lang.String address)` Removes the `DriverTag` at the given address.
`void`	`reschedule()` Reschedule all the current `ScheduledRequest`s.
`void`	`setConcurrentRequests(int concurrentRequests)` Sets the allowed number of concurrent requests.
`protected void`	`setState(DriverState state)`
`void`	`shutdown()` Called when a driver should cease all activities and shutdown any open connections.
`void`	`writeItems(java.util.List<? extends WriteItem> items)` Asynchronous write call for a list of items.

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

Methods inherited from interface com.inductiveautomation.xopc.driver.api.Driver
buildNode, getDriverStatusJSLibName, getDriverStatusJSUrl

- Field Detail
  - diagnosticsContext
```
protected DriverDiagnosticsImpl diagnosticsContext
```
  - log
```
protected LoggerEx log
```
  - executor
```
protected java.util.concurrent.ScheduledExecutorService executor
```
  - nodeManager
```
protected NodeManager nodeManager
```
  - builderFactory
```
protected NodeBuilderFactory builderFactory
```
- Constructor Detail
  - AbstractDriver
```
public AbstractDriver(DriverContext driverContext)
```
- Method Detail
  - readItems
```
public void readItems(java.util.List<? extends ReadItem> items)
```
    Description copied from interface: Driver
    
    Asynchronous read call for a list of items. Read results are reported by calling ReadItem.setValue(DataValue).
    
    Specified by:
    
    readItems in interface Driver
  - writeItems
```
public void writeItems(java.util.List<? extends WriteItem> items)
```
    Description copied from interface: Driver
    
    Asynchronous write call for a list of items. Write results are reported by calling WriteItem.setWriteStatus(StatusCode).
    
    Specified by:
    
    writeItems in interface Driver
  - browse
```
public void browse(BrowseOperation browseOp)
```
    Description copied from interface: Driver
    
    Asynchronous browse operation. When finished, call BrowseOperation.browseDone(StatusCode, List, Guid).
    
    Specified by:
    
    browse in interface Driver
  - shutdown
```
public void shutdown()
```
    Description copied from interface: Driver
    
    Called when a driver should cease all activities and shutdown any open connections. No further value updates should be processed.
    Once a driver instance has been shutdown it will never be started/used again; a new instance will be created and used if needed.
    
    Specified by:
    
    shutdown in interface Driver
  - getDriverState
```
public final DriverState getDriverState()
```
  - getDriverStatus
```
public java.lang.String getDriverStatus()
```
    Description copied from interface: Driver
    
    Returns the current status of the driver.
    
    Specified by:
    
    getDriverStatus in interface Driver
    
    Returns:
    
    The driver's current status, e.g. "Browsing", "Program Mode", "Connected", etc...
  - getDriverMetrics
```
public java.util.Optional<DriverMetrics> getDriverMetrics()
```
    Description copied from interface: Driver
    
    If this driver uses a traditional polling model, a DriverMetrics.
    
    Specified by:
    
    getDriverMetrics in interface Driver
    
    Returns:
    
    a DriverMetrics if supported by this driver.
  - connect
```
protected abstract void connect()
```
    A chance for implementations to do anything that is needed before moving into DriverState.Connected. When done, notifyConnectSucceeded() or notifyConnectFailed(Exception) must be called.
  - disconnect
```
protected abstract void disconnect()
```
    A chance for implementations to do anything that is needed before moving into DriverState.Disconnected. When done, notifyDisconnectDone() must be called.
  - notifyConnectSucceeded
```
public void notifyConnectSucceeded()
```
    Callback indicating that the result of connect() was a success.
    Clears the last connect error, sets DriverState.Connected, and starts any subscriptions.
    
    Since:
    
    Ignition 7.5.4, OPC-UA 1.5.4
  - notifyConnectFailed
```
public void notifyConnectFailed(java.lang.Exception connectError)
```
    Callback indicating that the result of connect() was a failure.
    The contents of connectError will be displayed to the user on the device status page of the Ignition gateway.
    
    Parameters:
    
    connectError - A user-facing error message that will be displayed on the device status page of the Ignition gateway.
    
    Since:
    
    Ignition 7.5.4, OPC-UA 1.5.4
  - notifyDisconnectDone
```
public void notifyDisconnectDone()
```
    A callback to notify AbstractDriver that a call to disconnect() is done.
    This will move the driver into DriverState.Disconnected and cancel any outstanding ScheduledRequests.
  - notifyConnectionLost
```
public void notifyConnectionLost()
```
    Notify AbstractDriver that the connection has unintentionally been lost. It is assumed that because the connection was lost, disconnect() does not need to be called.
    If DriverState is not currently DriverState.Disconnected then the following occurs:
    1. DriverState is set to DriverState.Disconnected.
    2. All outstanding ScheduledRequest's are canceled.
    3. A call to connect() will be scheduled.
  - setState
```
protected void setState(DriverState state)
```
  - postRequest
```
public void postRequest(Request<M> request,
                        int delay)
```
    Post a Request.
    
    Parameters:
    
    request - The Request to post.
    
    delay - The delay before posting.
  - reschedule
```
public void reschedule()
```
    Reschedule all the current ScheduledRequests. This implies that all requests will be re-optimized.
  - messageArrived
```
protected void messageArrived(M message)
```
    Notify AbstractDriver that a messaged arrived. This cannot be called on the same thread that Request.sendMessage() was invoked on.
    
    Parameters:
    
    message - The message that has arrived.
  - getDriverContext
```
public DriverContext getDriverContext()
```
    Returns:
    
    The DriverContext for this Driver.
  - getName
```
public java.lang.String getName()
```
    Returns:
    
    The user configured name for this driver instance.
  - getLogger
```
public LoggerEx getLogger()
```
    Returns:
    
    The logger used by this driver instance. This should be used as the base for subsequent loggers of objects belonging to this driver, such as Requests.
  - setConcurrentRequests
```
public void setConcurrentRequests(int concurrentRequests)
```
    Sets the allowed number of concurrent requests.
    The number of concurrent requests is the number of Request objects that can be sent ( Request.sendMessage()) at the same time without first receiving a response.
    
    Parameters:
    
    concurrentRequests - The allowed number of concurrent requests.
  - getConcurrentRequests
```
public int getConcurrentRequests()
```
    Returns:
    
    The currently allowed number of concurrent requests.
  - nextGuid
```
public Guid nextGuid()
```
    Returns:
    
    A new Guid representing the browse structure.
  - currentGuid
```
public Guid currentGuid()
```
    Returns:
    
    The current browse Guid.
  - getDiagnostics
```
public DriverDiagnostics getDiagnostics()
```
  - getRequestDiagnostics
```
public RequestDiagnostics getRequestDiagnostics(java.lang.String address)
```
  - getDriverTagAddressPrefix
```
public java.lang.String getDriverTagAddressPrefix()
```
    Returns:
    
    A prefix to be appended to all addresses received from DriverTag.getAddress() that differentiates DriverTag addresses from actual device addresses.
  - addDriverTag
```
public void addDriverTag(DriverTag tag)
```
    Description copied from interface: DriverTagManager
    
    Add a DriverTag.
    
    Specified by:
    
    addDriverTag in interface DriverTagManager
    
    Parameters:
    
    tag - The tag to add.
  - removeDriverTag
```
public void removeDriverTag(java.lang.String address)
```
    Description copied from interface: DriverTagManager
    
    Removes the DriverTag at the given address.
    If the address points to a folder then the folder and all its children will be recursively removed.
    
    Specified by:
    
    removeDriverTag in interface DriverTagManager
    
    Parameters:
    
    address - The address to remove.
  - findTag
```
public DriverTag findTag(java.lang.String address)
```
    Description copied from interface: DriverTagManager
    
    Find a DriverTag with the given address, if it exists.
    
    Specified by:
    
    findTag in interface DriverTagManager
    
    Parameters:
    
    address - The address of the DriverTag.
    
    Returns:
    
    The DriverTag for address, or null if none exists.
  - optimizeRead
```
protected abstract java.util.List<java.util.List<? extends ReadItem>> optimizeRead(java.util.List<? extends ReadItem> items)
```
    Optimize the given list of items into sub-lists, where each sub-list is expected to fit into a single Request when createReadRequest(List) is called.
    Things to take into consideration when optimizing might be:
    - Type of item being read
    - Address/location of item being read
    - Limitations on the number of items that can be read at once
    - Limitations on the size of a request packet
    - Limitations on the size of the response packet this request may generate
    - The speed at which a device responds to reading items based on how they are grouped
    These and any other limitations are, obviously, highly implementation specific.
    Parameters:
    
    items - The items to optimize.
    
    Returns:
    
    A list of lists, where each sub-list is expected to fit into a single Request.
  - optimizeSubscribe
```
protected java.util.List<java.util.List<? extends ReadItem>> optimizeSubscribe(java.util.List<? extends ReadItem> items)
```
    Optimize the given list of items into sub-lists, where each sub-list is expected to fit into a single Request when createSubscribeRequest(List) is called.
    By default, this implementation simply defers to optimizeRead(List). Override if you need to do anything special when optimizing a request that will be used for a subscribe instead of a read.
    
    Parameters:
    
    items - The items to optimize.
    
    Returns:
    
    A list of lists, where each sub-list is expected to fit into a single Request.
  - optimizeWrite
```
protected java.util.List<java.util.List<? extends WriteItem>> optimizeWrite(java.util.List<? extends WriteItem> items)
```
    Optimize the given list of items into sub-lists where each sub-list is expected to fit into a single Request when createWriteRequest(List) is called.
    Similar considerations as when optimizing reads should be taken.
    
    Parameters:
    
    items - The items to optimize into sub-lists.
    
    Returns:
    
    A list of lists, where each sub-list is expected to fit inside a single write Request.
  - createReadRequest
```
protected abstract Request<M> createReadRequest(java.util.List<? extends ReadItem> items)
```
    Create a read Request with the given items. These items are guaranteed to be a sub-list previously generated by a call to optimizeRead(List) and should therefore fit into single Request.
    
    Parameters:
    
    items - The items that make up this Request.
    
    Returns:
    
    A Request for the given items.
  - createSubscribeRequest
```
protected Request<M> createSubscribeRequest(java.util.List<? extends ReadItem> items)
```
    Create a read Request with the given items. These items are guaranteed to be a sub-list previously generated by a call to optimizeSubscribe(List) and should therefore fit into single Request.
    By default, this implementation simply defers to createReadRequest(List). Override if you need to do anything special when creating a request that will be used for a subscribe instead of a read.
    
    Parameters:
    
    items - The items that make up this Request.
    
    Returns:
    
    A Request for the given items.
  - createWriteRequest
```
protected abstract Request<M> createWriteRequest(java.util.List<? extends WriteItem> items)
```
    Create a write Request with the given items. These items are guaranteed to be a sub-list previously generated by a call to optimizeWrite(List) and should therefore fit into a single Request.
    
    Parameters:
    
    items - The items that make up this write Request.
    
    Returns:
    
    A write Request for the given items.
  - createBrowseRequest
```
protected abstract Request<M> createBrowseRequest(BrowseOperation browseOp)
```
    Create a browse Request for the given BrowseOperation.
    
    If the implementation does not actually need to post a Request to complete the browse then BrowseOperation.browseDone(StatusCode, List, Guid) can be called whenever browsing is complete and a null value can be returned.
    
    Parameters:
    
    browseOp - The BrowseOperation for this Request.
    
    Returns:
    
    A browse Request for the given BrowseOperation, or null if no Request is necessary to complete the browse.
  - getRequestKey
```
protected abstract java.lang.Object getRequestKey(M message)
```
    Extract the request key from the given message. This key is used to identify the Request that this message is a response to.
    
    Parameters:
    
    message - The message to extract a key from.
    
    Returns:
    
    A key for this message.
  - isBrowsingSupported
```
protected abstract boolean isBrowsingSupported()
```
    Returns:
    
    True if this driver supports browsing.
  - isOfflineBrowsingSupported
```
protected abstract boolean isOfflineBrowsingSupported()
```
    Returns:
    
    True if this driver supports offline browsing (browsing regardless of connection state).

Class AbstractDriver<M>

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Methods inherited from interface com.inductiveautomation.xopc.driver.api.Driver

Field Detail

diagnosticsContext

log

executor

nodeManager

builderFactory

Constructor Detail

AbstractDriver

Method Detail

readItems

writeItems

browse

shutdown

getDriverState

getDriverStatus

getDriverMetrics

connect

disconnect

notifyConnectSucceeded

notifyConnectFailed

notifyDisconnectDone

notifyConnectionLost

setState

postRequest

reschedule

messageArrived

getDriverContext

getName

getLogger

setConcurrentRequests

getConcurrentRequests

nextGuid

currentGuid

getDiagnostics

getRequestDiagnostics

getDriverTagAddressPrefix

addDriverTag

removeDriverTag

findTag

optimizeRead

optimizeSubscribe

optimizeWrite

createReadRequest

createSubscribeRequest

createWriteRequest

createBrowseRequest

getRequestKey

isBrowsingSupported

isOfflineBrowsingSupported