PvaClient is a synchronous API for accessing PVData via PVAccess. It also provides a number of convenience methods. It allows the client to request access without checking for failure, but throws an exception if a request fails. A client can also check for failues and thus prevent exceptions.
The PvaClient API has the following features:
Simple examples of using pva:
// pvaGet PvaClientPtr pva = PvaClient::create(); double value = pva->channel("exampleDouble")->get()->getData()->getDouble(); // pvaPut PvaClientChannelPtr channel = pva->channel("exampleDouble"); PvaClientPutPtr put = channel->put(); PvaClientPutDataPtr putData = put->getData(); putData->putDouble(3.0); put->put(); // pvaMonitor PvaClientMonitorPtr monitor = pva->channel("examplePowerSupply")->monitor(""); PvaClientMonitorDataPtr pvaData = monitor->getData(); while(true) { monitor->waitEvent(); cout << "changed\n"; pvaData->showChanged(cout); cout << "overrun\n"; pvaData->showOverrun(cout); monitor->releaseEvent(); } // pvaProcess PvaClientChannelPtr channel = pva->channel("exampleDouble"); PvaClientProcessPtr process = channel->createProcess(); process->process();
pvClientCPP/example includes a number of examples.
pvaClient does not provide support for:
An instance of PvaClient is obtained via the call:
PvaClientPtr pva = PvaClient::create();
PvaClient has methods to create instances of PvaClientChannel. The client can specify the provider name or use the default provider. The client can manage it's own channels or can let pvaClient cache channels. An example of using the cached method is:
PvaClientChannelPtr pvaChannel = pva->channel("exampleDouble");
This will attempt to connect to channel exampleDouble. Since the client did not specify a timeout an exception wll be thrown if the connection request fails. The client will block until the connection is made or an exception is thrown. If the request succeeds, pva caches the pvaChannel so that if the client makes another request for the same channel the cached object is returned to the client.
An example of using a non cached method is:
PvaClientChannelPtr pvaChannel = pva->createChannel("exampleDouble");
This will create an PvaClientChannel and return it to the client. The client must itself connect. This is useful if the client wants to connect to multiple channels in parallel.
This provides methods for connecting to a channel and for creating instances of PvaClientField, PvaClientProcess, ..., PvaClientPutGet.
Connection must be made before any create method is called or an exception is raised. The following is a synchronous connection request:
pvaChannel->connect(5.0); // BLOCKS AND THROWS IF NO CONNECT
This blocks until then connection is made or until timout occurs. An exception is raised if the connection request fails.
The same request can be made without blocking and without exceptions.
pvaChannel->issueConnect(); // DOES NOT BLOCK ..... Status status =pvaChannel->waitConnect(5.0); // BLOCKS DOES NOT THROW if(!status.isOK()) { // failure do something }
Once the channel is connected other PvaClient objects can be created. For example:
PvaClientGetPtr pvaGet = pvaChannel->get(); // DOES BLOCK
This is a caching request. If the client already has made an identical request the client will receive the cached object. If a new pvaGet is created than it is connected before it is returned to the client.
The client can also managed it's own objects:
PvaClientGetPtr pvaGet = pvaChannel->createGet(); // DOES NOT BLOCK
The client must connect the pvaGet.
This provides the data returned by pvaGet and pvaPutGet. It is obtained via:
PvaClientGetDataPtr pvaData = pvaGet->getData();
It provides methods to get everything returned by channelGet. In addition there are methods that make it easier to handle a value field that is a scalar or a scalarArray. Also for a scalar that is a double or a scalarArray with element type double.
An example is:
double value = pvaData->getDouble();
It also keeps a bitSet showing which fields have changed since the last channelGet or channelPutGet.
To the client this looks identical to PvaClientGetData except that it provides two BitSets: changedBitSet and overrrunBitSet. It is used by pvaMonitor.
This is used to provided data for pvaPut and pvaPutGet. It has many of the same methods as pvaGetData. It does not have a bitSet. It also has put methods like:
void pvaData->putDouble(5.0);
This provides methods to connect to channelGet and to issue get request. To connect via a single synchronous call:
eastGet->connect(); // BLOCKS AND CAN THROW
This can also be done in two steps:
pvaGet->issueConnect(); // DOES NOT BLOCK ... Status status = pvaGet->waitConnect(); // BLOCKS AND DOES NOT HROW
Once connected gets are issued via either:
void pvaGet->get(); // BLOCKS AND CAN THROWor
pvaGet->issueGet(); // DOES NOT BLOCK ... Status status = pvaGet->waitGet(); // BLOCKS AND DOES NOT THROW
This is similar to pvaGet except that it wraps channelPut instead of channelGet.
Once connected puts are issued via either:
void pvaPut->put(); // BLOCKS AND CAN THROWor
pvaPut->issuePut(); // DOES NOT BLOCK ... Status status = pvaPut->waitPut(); // BLOCKS AND DOES NOT THROW
Connecting is similar to pvaGet and pvaPut. The other methods are:
Connecting is similar to pvaGet. It has methods:
Connecting is similar to pvaGet. It has methods:
Look at javaDoc for details.
This provides methods for connecting to multiple channels.
This provides support for channelGet to multiple channels where each channel has a value field that is a numeric scalar.
This provides support for channelPut to multiple channels where each channel has a value field that is a numeric scalar.
This provides support for monitoring changes to multiple channels where each channel has a value field that is a numeric scalar.
This provides support for channelGet to multiple channels where each channel has a value field that has any valid type.
This provides support for channelPut to multiple channels where each channel has a value field that has any valid type.
This provides support for monitoring changes to multiple channels where each channel has a value field that has any valid type.
This provides support for monitoring changes to multiple channels where each channel has a value field that has any valid type. The client can get the data as normative type NTMultiChannel.