epics/pvaClient
0
0
Fork 0
Code Issues Pull Requests Projects Wiki Activity

Merge pull request #1 from mrkraimer/master

Browse Source 
easyPVACPP to pvClientCPP conversion
This commit is contained in:
Marty Kraimer
2015-06-17 15:32:47 -04:00
parent 49368493ce b1594e6b78
commit 1fa3eaa14c
51 changed files with 2751 additions and 2512 deletions
Download Patch File Download Diff File Expand all files Collapse all files

12
.gitignore vendored Normal file
View File

@@ -0,0 +1,12 @@
bin/
lib/
doc/
include/
db/
dbd/
documentation/html
documentation/*.tag
envPaths
configure/*.local
!configure/ExampleRELEASE.local
**/O.*

8
.hgflow
View File

@@ -1,8 +0,0 @@
[branchname]
master = master
develop = default
feature = feature/
release = release/
hotfix = hotfix/
support = support/

11
.hgignore
View File

@@ -1,11 +0,0 @@
^QtC-
bin/
lib/
doc/
include/
db/
dbd/
documentation/html
envPaths
configure/.*\.local
/O\..*

2
README.txt
View File

@@ -6,4 +6,4 @@ edit RELEASE.local
cd ..
make
Now read documentation/easyPVA.html
Now read documentation/pvaClientCPP.html

2
configure/ExampleRELEASE.local
View File

@@ -2,7 +2,7 @@
TEMPLATE_TOP=$(EPICS_BASE)/templates/makeBaseApp/top
EPICS_BASE=/home/install/epics/base
V4BASE=/home/hg
V4BASE=/home/epicsv4
PVCOMMON=${V4BASE}/pvCommonCPP
PVDATA=${V4BASE}/pvDataCPP
NORMATIVETYPES=${V4BASE}/normativeTypesCPP

9
documentation/easyPVA.html → documentation/easyPVA_20150609.html
View File

@@ -36,16 +36,21 @@
</a> </dd>
<dt>Latest version:</dt>
<dd><a
href="easyPVA_20150325.html">easyPVA_20150325.html</a>
href="easyPVA_20150609.html">easyPVA_20150609.html</a>
</dd>
<dt>Previous version:</dt>
<dd>none</dd>
<dd><a
href="easyPVA_20150325.html">easyPVA_20150325.html</a>
</dd>
<dt>Editors:</dt>
<dd>Marty Kraimer, BNL</dd>
<dd>Matej Sekoranja, Cosylab</dd>
</dl>
<h2 class="nocount">Abstract</h2>
<p><b>NO LONGER SUPPPORTED:</b>
The functionality has been moved to pvAccessCPP and EasyPva renamed to Pva.
</p>
<p>EasyPVA (Easy PVAccess) is a software library that provides to an EPICS client programmer, a friendly
client side programming interface to the data of an EPICS based control system. It is intended

199
documentation/pvClientCPP.html Normal file
View File

@@ -0,0 +1,199 @@
<?xml version="1.0" encoding="iso-8859-1"?>
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
<meta http-equiv="content-type" content="text/html; charset=iso-8859-1" />
<title>EPICS pva</title>
<link rel="stylesheet" type="text/css"
href="http://epics-pvdata.sourceforge.net/base.css" />
<link rel="stylesheet" type="text/css"
href="http://epics-pvdata.sourceforge.net/epicsv4.css" />
<style type="text/css">
/*<![CDATA[*/
.about { margin-left: 3em; margin-right: 3em; font-size: .83em}
table { margin-left: auto; margin-right: auto }
.diagram { text-align: center; margin: 2.5em 0 }
body { margin-right: 10% }
/*]]>*/</style>
<!-- Script that generates the Table of Contents -->
<script type="text/javascript" src="http://epics-pvdata.sourceforge.net/script/tocgen.js"></script>
</head>
<body>
<div class="head">
<h1>EPICS pvaClientCPP</h1>
<!-- Maturity: Working Draft or Request for Comments, or Recommendation, and date. -->
<h2 class="nocount">EPICS V4 Working Group, Working Draft,
29-May-2015</h2>
<dl>
<dt>This version:</dt>
<dd><a
href="pvaClientCPP.html">pvaClientCPP.html
</a> </dd>
<dt>Latest version:</dt>
<dd>Still under revision</dd>
<dt>Previous version:</dt>
<dd><a
href="easyPVA_20150609.html">easyPVA_20150609.html</a>
</dd>
<dt>Editors:</dt>
<dd>Marty Kraimer, BNL</dd>
</dl>
<h2 class="nocount">Abstract</h2>
<p>pvaClient is a software library that provides to an EPICS client programmer, a friendly
client side programming interface to the data of an EPICS based control system. It is intended
for such uses as rapid development of ad hoc programs by controls engineers, or to provide
scientists a way to directly develop analytical applications.</p>
<p>Specifically, pvaClient provides a synchronous interface for pvAccess, which is the
software support for high speed controls network communications used in EPICS version 4.
pvAccess provides a callback based interface, which can be hard to use.
pvaClient provides an interface that does not require callbacks even for monitors.
</p>
p>
pvaClientChannel provides many "convenience" methods to directly get and put
scalar and scalarArray data types.
Additional methods provide access to the full features of pvAccess.
</p>
<p>
pvaClientMultiChannel provides access to data from multiple channels.
It can be used directly by a client or via pvaClientMultiDouble or pvaClientNTMultiChannel.
pvaClientMultiDouble allows the client to get and put data to multiple channels.
But each channel must have a value field that is a numeric scalar.
pvaClientNTMultiChannel allows the client to get and put data to multiple channels.
Each channel must have a value field.
The data for the channels is presented via normative type NTMultiChannel.
</p>
<!-- last para of Abstract is boilerplate reference to EPICS -->
<p>For more information about EPICS generally, please refer to the home page of the <a
href="http://www.aps.anl.gov/epics/">Experimental Physics and Industrial
Control System</a>.</p>
<h2 class="nocount">Status of this Document and of the pvaClient Software</h2>
<p>pvaClientCPP is ready for use.</p>
</div> <!-- head -->
<div id="toc">
<h2 class="nocount">Table of Contents</h2>
</div>
<!-- Place what you would like in the Table of Contents, inside the contents div -->
<div id="contents" class="contents">
<hr />
<h2>Introduction</h2>
<p>pvaClient is a synchronous API for accessing PVData via PVAccess. It provides
an interface to many of the features provided by pvData and pvAccess.</p>
<p>This document describes the layout of the source files in this project.</p>
<p>
A user overview is available via
<a
href="./pvaClientOverview.html">pvaClientOverview.html
</a>
</p>
<p>
Doxygen documentation is available at
<a
href="./html/index.html">doxygenDoc
</a>
</p>
<h2>Example Database</h2>
<p>The examples and tests require that an example pvAccess server is runnimg.
This distribution has a file <b>exampleDatabasePvaClient.zip</b>.
When unzipped this is used to create an example IOC database.
</p>
<p>
After unzipping the file:
</p>
<pre>
cd configure
cp ExampleRELEASE.local RELEASE.local
edit RELEASE.local
cd ..
make
cd iocBoot/exampleDatabase
../../bin/&lt;arch:&gt;/exampleDatabase st.cmd
</pre>
<h2>Testing</h2>
<p>The tests will fail unless the example database is running.</p>
<p>Once it is running:</p>
<pre>
make runtests
</pre>
<h2>Examples</h2>
<p>Examples are in directory <b>pvaExample/src</b>.
An example of how to run them is:</p>
<pre>
mrk&gt; pwd
/home/epicsv4/pvAccessCPP/pvaExample
mrk&gt; bin/linux-x86_64/examplepvaClientGet
</pre>
<p>The following is a brief description of each example.
In order to understand each example it
helps to also look at the source for the example.</p>
<h2>examplePvaClientGet</h2>
<p>This has a number of examples:</p>
<dl>
<dt>exampleDouble</dt>
<dd>
This shows two methods for getting data from a channel that has a numeric
scalar value field.
</dd>
<dt>exampleDoubleArray</dt>
<dd>
This shows two methods for getting data from a channel that has a
double array value field.
</dd>
<dt>exampleCADouble</dt>
<dd>
This is like exampleDouble except it uses provider <b>ca</b>.
</dd>
<dt>exampleCADoubleArray</dt>
<dd>
This is like exampleDoubleArray except it uses provider <b>ca</b>.
</dd>
<dt>examplePowerSupply</dt>
<dd>
This is an example of getting data from a channel that does not
have a value field.
</dd>
</dl>
<h2>examplePvaClientMonitor</h2>
<p>This is an example of creating a monitor on a channel.
It monitors a channel that models a powerSupply, i. e. it is not a "standard" record.
It does not have a value field.
</p>
<p>After starting the example a change can be made to the powerSupply by issuing:</p>
<pre>
pvput -r "power.value,voltage.value" examplePowerSupply 6 6
</pre>
<h2>examplePvaClientPut</h2>
<p>This example gets and puts to channel exampleDouble.</p>
<h2>examplePvaClientProcess</h2>
<p>This example makes a process request to channel exampleDouble.</p>
<h2>helloWorldPutGet</h2>
<p>This is an example of issuing a channelPutGet.</p>
<h2>examplePvaClientMultiDouble</h2>
<p>This is an example of issuing gets and puts to multiple channels where each
channel has a numeric scalar value field.</p>
<h2>examplePvaClientNTMultiChannel</h2>
<p>This is an example of using NDMultiChannel to obtain data from multiple channels.
</p>
<h2>helloWorldRPC</h2>
<p>This is an example of issuing a channelRPC request.
It does <b>not</b> use pva.</p>
</div> <!-- class="contents" -->
</body>
</html>

166
documentation/overview.html → documentation/pvaClientOverview.html
View File

@@ -4,7 +4,7 @@
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
<meta http-equiv="content-type" content="text/html; charset=iso-8859-1" />
<title>easyPVA C++ Overview</title>
<title>pva C++ Overview</title>
<link rel="stylesheet" type="text/css"
href="http://epics-pvdata.sourceforge.net/base.css" />
<link rel="stylesheet" type="text/css"
@@ -25,7 +25,7 @@
<body>
<div class="head">
<h1>easyPVA C++ Overview</h1>
<h1>PvaClient C++ Overview</h1>
</div> <!-- head -->
@@ -39,135 +39,135 @@
<h2>Introduction</h2>
<p>EasyPVA is a synchronous API for accessing PVData via PVAccess.
It also provides a number of convience methods.
<p>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 when a reuest fails.
A client can also check for failues and thus prevent failures.</p>
but throws an exception if a request fails.
A client can also check for failues and thus prevent exceptions.</p>
<p>The EasyPVA API has the following features:</p>
<p>The PvaClient API has the following features:</p>
<ol>
<li>Provides a synchronous API rather than the callback API provided by pvAccess.</li>
<li>Makes common requests easy.</li>
<li>Makes common requests pva.</li>
<li>Provides full access to the pvAccess API for more demanding
applications</li>
<li>Allows efficient client side programs.</li>
<li>Takes care of most object resource management problems.</li>
</ol>
<p>Simple examples of using easyPVA:</p>
<p>Simple examples of using pva:</p>
<pre>
// easyGet
EasyPVAPtr easyPVA = EasyPVA::create();
double value = easyPVA-&gt;channel("exampleDouble")-&gt;get()-&gt;getData()-&gt;getDouble();
// pvaGet
PvaClientPtr pva = PvaClient::create();
double value = pva-&gt;channel("exampleDouble")-&gt;get()-&gt;getData()-&gt;getDouble();
// easyPut
EasyChannelPtr channel = easyPVA-&gt;channel("exampleDouble");
EasyPutPtr put = channel-&gt;put();
EasyPutDataPtr putData = put-&gt;getData();
// pvaPut
PvaClientChannelPtr channel = pva-&gt;channel("exampleDouble");
PvaClientPutPtr put = channel-&gt;put();
PvaClientPutDataPtr putData = put-&gt;getData();
putData-&gt;putDouble(3.0); put-&gt;put();
// easyMonitor
EasyMonitorPtr monitor = easyPVA-&gt;channel("examplePowerSupply")-&gt;monitor("");
EasyMonitorDataPtr easyData = monitor-&gt;getData();
// pvaMonitor
PvaClientMonitorPtr monitor = pva-&gt;channel("examplePowerSupply")-&gt;monitor("");
PvaClientMonitorDataPtr pvaData = monitor-&gt;getData();
while(true) {
monitor-&gt;waitEvent();
cout &lt;&lt; "changed\n";
easyData-&gt;showChanged(cout);
pvaData-&gt;showChanged(cout);
cout &lt;&lt; "overrun\n";
easyData-&gt;showOverrun(cout);
pvaData-&gt;showOverrun(cout);
monitor-&gt;releaseEvent();
}
// easyProcess
EasyChannelPtr channel = easyPVA-&gt;channel("exampleDouble");
EasyProcessPtr process = channel-&gt;createProcess();
// pvaProcess
PvaClientChannelPtr channel = pva-&gt;channel("exampleDouble");
PvaClientProcessPtr process = channel-&gt;createProcess();
process-&gt;process();
</pre>
<p><b>easyPVACPP</b> includes a number of examples.</p>
<p>easyPVA does <b>not</b> provide support for:</p>
<p><b>pvaExample</b> includes a number of examples.</p>
<p>pva does <b>not</b> provide support for:</p>
<dl>
<dt>ChannelArray</dt>
<dd>TBD</dd>
<dt>ChannelRPC</dt>
<dd>pvAccess itself already provides an easy to use synchronous interface.
<dd>pvAccess itself already provides a synchronous interface.
The examples include helloWorldRPC, which is an example of using channelRP.
</dd>
</dl>
<h2>EasyPVA</h2>
<p>An instance of EasyPVA is obtained via the call:</p>
<h2>PvaClient</h2>
<p>An instance of PvaClient is obtained via the call:</p>
<pre>
EasyPVAPtr easyPVA = EasyPVA::create();
PvaClientPtr pva = PvaClient::create();
</pre>
<p>EasyPVA has methods to create instances of <b>EasyChannel</b>.
<p>PvaClient has methods to create instances of <b>PvaClientChannel</b>.
The client can specify the provider name or use the default provider.
The client can manage it's own channels or can let easyPVA cache channels.
The client can manage it's own channels or can let pva cache channels.
An example of using the cached method is:</p>
<pre>
EasyChannelPtr easyChannel = easyPVA-&gt;channel("exampleDouble");
PvaClientChannelPtr pvaChannel = pva-&gt;channel("exampleDouble");
</pre>
<p>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, easyPVA caches the easyChannel so that if the
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.
</p>
<p>An example of using a non cached method is:</p>
<pre>
EasyChannelPtr easyChannel = easyPVA-&gt;createChannel("exampleDouble");
PvaClientChannelPtr pvaChannel = pva-&gt;createChannel("exampleDouble");
</pre>
<p>This will create an EasyChannel and return it to the client.
<p>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.
</p>
<h2>EasyChannel - Wrapper For Single Channel</h2>
<h3>EasyChannel</h3>
<h2>PvaClientChannel - Wrapper For Single Channel</h2>
<h3>PvaClientChannel</h3>
<p>This provides methods for connecting to a channel and for creating instances of
EasyField, EasyProcess, ..., EasyPutGet.</p>
PvaClientField, PvaClientProcess, ..., PvaClientPutGet.</p>
<p>Connection must be made before any create method is called or
an exception is raised.
The following is a synchronous connection request:</p>
<pre>
easyChannel-&gt;connect(5.0); // BLOCKS AND THROWS IF NO CONNECT
pvaChannel-&gt;connect(5.0); // BLOCKS AND THROWS IF NO CONNECT
</pre>
<p>This blocks until then connection is made or until timout occurs.
An exception is raised if the connection request fails.
</p>
<p>The same request can be made without blocking and without exceptions.</p>
<pre>
easyChannel-&gt;issueConnect(); // DOES NOT BLOCK
pvaChannel-&gt;issueConnect(); // DOES NOT BLOCK
.....
Status status =easyChannel-&gt;waitConnect(5.0); // BLOCKS DOES NOT THROW
Status status =pvaChannel-&gt;waitConnect(5.0); // BLOCKS DOES NOT THROW
if(!status.isOK()) {
// failure do something
}
</pre>
<p>Once the channel is connected other Easy objects can be created.
<p>Once the channel is connected other PvaClient objects can be created.
For example:</p>
<pre>
EasyGetPtr easyGet = easyChannel-&gt;get(); // DOES BLOCK
PvaClientGetPtr pvaGet = pvaChannel-&gt;get(); // DOES BLOCK
</pre>
<p>This is a caching request.
If the client already has made an identical request the client will receive the
cached object.
If a new easyGet is created than it is connected before it is returned to the client.
If a new pvaGet is created than it is connected before it is returned to the client.
</p>
<p>The client can also managed it's own objects:</p>
<pre>
EasyGetPtr easyGet = easyChannel-&gt;createGet(); // DOES NOT BLOCK
PvaClientGetPtr pvaGet = pvaChannel-&gt;createGet(); // DOES NOT BLOCK
</pre>
<p>The client must connect the easyGet.</p>
<p>The client must connect the pvaGet.</p>
<h3>EasyGetData</h3>
<p>This provides the data returned by easyGet and easyPutGet.
<h3>PvaClientGetData</h3>
<p>This provides the data returned by pvaGet and pvaPutGet.
It is obtained via:</p>
<pre>
EasyGetDataPtr easyData = easyGet-&gt;getData();
PvaClientGetDataPtr pvaData = pvaGet-&gt;getData();
</pre>
<p>It provides methods to get everything returned by channelGet.
In addition there are methods that make it easier to handle a value
@@ -176,24 +176,24 @@ Also for a scalar that is a double or a scalarArray with element type double.
</p>
<p>An example is:</p>
<pre>
double value = easyData-&gt;getDouble();
double value = pvaData-&gt;getDouble();
</pre>
<p>It also keeps a bitSet showing which fields have changed since the last channelGet or channelPutGet.</p>
<h3>EasyMonitorData</h3>
<p>To the client this looks identical to EasyGetData except that
<h3>PvaClientMonitorData</h3>
<p>To the client this looks identical to PvaClientGetData except that
it provides two BitSets: changedBitSet and overrrunBitSet.
It is used by easyMonitor.
It is used by pvaMonitor.
</p>
<h3>EasyPutData</h3>
<p>This is used to provided data for easyPut and easyPutGet.
It has many of the same methods as easyGetData.
<h3>PvaClientPutData</h3>
<p>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:</p>
<pre>
void easyData-&gt;putDouble(5.0);
void pvaData-&gt;putDouble(5.0);
</pre>
<h3>EasyGet</h3>
<h3>PvaClientGet</h3>
<p>This provides methods to connect to channelGet and to issue get request.
To connect via a single synchronous call:</p>
<pre>
@@ -201,35 +201,35 @@ eastGet-&gt;connect(); // BLOCKS AND CAN THROW
</pre>
<p>This can also be done in two steps:</p>
<pre>
easyGet-&gt;issueConnect(); // DOES NOT BLOCK
pvaGet-&gt;issueConnect(); // DOES NOT BLOCK
...
Status status = easyGet-&gt;waitConnect(); // BLOCKS AND DOES NOT HROW
Status status = pvaGet-&gt;waitConnect(); // BLOCKS AND DOES NOT HROW
</pre>
<p>Once connected gets are issued via either:</p>
<pre>
void easyGet-&gt;get(); // BLOCKS AND CAN THROW
void pvaGet-&gt;get(); // BLOCKS AND CAN THROW
</pre>
or
<pre>
easyGet-&gt;issueGet(); // DOES NOT BLOCK
pvaGet-&gt;issueGet(); // DOES NOT BLOCK
...
Status status = easyGet-&gt;waitGet(); // BLOCKS AND DOES NOT THROW
Status status = pvaGet-&gt;waitGet(); // BLOCKS AND DOES NOT THROW
</pre>
<h3>EasyPut</h3>
<p>This is similar to easyGet except that it wraps channelPut instead of channelGet.
<h3>PvaClientPut</h3>
<p>This is similar to pvaGet except that it wraps channelPut instead of channelGet.
</p>
<p>Once connected puts are issued via either:</p>
<pre>
void easyPut-&gt;put(); // BLOCKS AND CAN THROW
void pvaPut-&gt;put(); // BLOCKS AND CAN THROW
</pre>
or
<pre>
easyPut-&gt;issuePut(); // DOES NOT BLOCK
pvaPut-&gt;issuePut(); // DOES NOT BLOCK
...
Status status = easyPut-&gt;waitPut(); // BLOCKS AND DOES NOT THROW
Status status = pvaPut-&gt;waitPut(); // BLOCKS AND DOES NOT THROW
</pre>
<h3>EasyMonitor</h3>
<p>Connecting is similar to easyGet and easyPut.
<h3>PvaClientMonitor</h3>
<p>Connecting is similar to pvaGet and pvaPut.
The other methods are:</p>
<dl>
<dt>start</dt>
@@ -238,7 +238,7 @@ The other methods are:</p>
<dd>Stops monitoring</dd>
<dt>poll</dt>
<dd>polls for a monitorEvent.
The data is avalable via easyMonitorData.
The data is avalable via pvaMonitorData.
</dd>
<dt>releaseEvent</dt>
<dd>Release the data from the last poll.
@@ -251,8 +251,8 @@ The other methods are:</p>
<dt>setRequester</dt>
<dd>A client callback is registered to receive notice of monitorEvents.</dd>
</dl>
<h3>EasyProcess</h3>
<p>Connecting is similar to easyGet.
<h3>PvaClientProcess</h3>
<p>Connecting is similar to pvaGet.
It has methods:</p>
<dl>
<dt>process</dt>
@@ -263,8 +263,8 @@ It has methods:</p>
<dt>waitProcess</dt>
<dd>Wait for process to complete.</dd>
</dl>
<h3>EasyPutGet</h3>
<p>Connecting is similar to easyGet.
<h3>PvaClientPutGet</h3>
<p>Connecting is similar to pvaGet.
It has methods:</p>
<dl>
<dt>putGet</dt>
@@ -285,29 +285,29 @@ It has methods:</p>
<dd>Gets the data for the put part of channelPutGet.</dd>
<dt>getPutData</dt>
<dd>
Returns the EasyData for the put part of channelPutGet.
Returns the PvaClientData for the put part of channelPutGet.
</dd>
<dt>getGetData</dt>
<dd>
Returns the EasyData for the get part of channelPutGet.
Returns the PvaClientData for the get part of channelPutGet.
</dd>
</dl>
<p>Look at javaDoc for details.</p>
<h2>EasyMultiChannel - Wrapper For Multiple Channels</h2>
<h3>EasyMultiChannel</h3>
<h2>PvaClientMultiChannel - Wrapper For Multiple Channels</h2>
<h3>PvaClientMultiChannel</h3>
<p>This provides methods for connecting to multiple channels.
A client can either use EasyMultiChannel directly or use EasyMultiDouble or EasyNTMultiChannel.
A client can either use PvaClientMultiChannel directly or use PvaClientMultiDouble or PvaClientNTMultiChannel.
But both impose restrictions on what can be accessed.
</p>
<h3>EasyMultiDouble</h3>
<h3>PvaClientMultiDouble</h3>
<p>This provides support for gets and puts to the value field of multiple channels.
Each channel must have a value field that is a numeric scalar.
The client always sees the data as a PVDoubleArray.
All channels must connect.
If any problems occur an exception is thrown.
</p>
<h3>EasyNTMultiChannel</h3>
<h3>PvaClientNTMultiChannel</h3>
<p>This provides support for gets and puts to the value field of multiple channels.
Each channel must have a value field.
The client always sees the data as a NTMultiChannel, which is one

78
example/src/Makefile
View File

@@ -5,52 +5,52 @@ include $(TOP)/configure/CONFIG
# ADD MACRO DEFINITIONS AFTER THIS LINE
PROD_HOST += exampleEasyProcess
exampleEasyProcess_SRCS += exampleEasyProcess.cpp
exampleEasyProcess_LIBS += easyPVA
exampleEasyProcess_LIBS += pvAccess
exampleEasyProcess_LIBS += pvData
exampleEasyProcess_LIBS += Com
PROD_HOST += examplePvaClientProcess
examplePvaClientProcess_SRCS += examplePvaClientProcess.cpp
examplePvaClientProcess_LIBS += pvaClient
examplePvaClientProcess_LIBS += pvAccess
examplePvaClientProcess_LIBS += pvData
examplePvaClientProcess_LIBS += Com
PROD_HOST += exampleEasyGet
exampleEasyGet_SRCS += exampleEasyGet.cpp
exampleEasyGet_LIBS += easyPVA
exampleEasyGet_LIBS += pvAccess
exampleEasyGet_LIBS += pvData
exampleEasyGet_LIBS += Com
PROD_HOST += examplePvaClientGet
examplePvaClientGet_SRCS += examplePvaClientGet.cpp
examplePvaClientGet_LIBS += pvaClient
examplePvaClientGet_LIBS += pvAccess
examplePvaClientGet_LIBS += pvData
examplePvaClientGet_LIBS += Com
PROD_HOST += exampleEasyPut
exampleEasyPut_SRCS += exampleEasyPut.cpp
exampleEasyPut_LIBS += easyPVA
exampleEasyPut_LIBS += pvAccess
exampleEasyPut_LIBS += pvData
exampleEasyPut_LIBS += Com
PROD_HOST += examplePvaClientPut
examplePvaClientPut_SRCS += examplePvaClientPut.cpp
examplePvaClientPut_LIBS += pvaClient
examplePvaClientPut_LIBS += pvAccess
examplePvaClientPut_LIBS += pvData
examplePvaClientPut_LIBS += Com
PROD_HOST += exampleEasyMonitor
exampleEasyMonitor_SRCS += exampleEasyMonitor.cpp
exampleEasyMonitor_LIBS += easyPVA
exampleEasyMonitor_LIBS += pvAccess
exampleEasyMonitor_LIBS += pvData
exampleEasyMonitor_LIBS += Com
PROD_HOST += examplePvaClientMonitor
examplePvaClientMonitor_SRCS += examplePvaClientMonitor.cpp
examplePvaClientMonitor_LIBS += pvaClient
examplePvaClientMonitor_LIBS += pvAccess
examplePvaClientMonitor_LIBS += pvData
examplePvaClientMonitor_LIBS += Com
PROD_HOST += exampleEasyMultiDouble
exampleEasyMultiDouble_SRCS += exampleEasyMultiDouble.cpp
exampleEasyMultiDouble_LIBS += easyPVA
exampleEasyMultiDouble_LIBS += pvAccess
exampleEasyMultiDouble_LIBS += pvData
exampleEasyMultiDouble_LIBS += Com
PROD_HOST += examplePvaClientMultiDouble
examplePvaClientMultiDouble_SRCS += examplePvaClientMultiDouble.cpp
examplePvaClientMultiDouble_LIBS += pvaClient
examplePvaClientMultiDouble_LIBS += pvAccess
examplePvaClientMultiDouble_LIBS += pvData
examplePvaClientMultiDouble_LIBS += Com
PROD_HOST += exampleEasyNTMultiChannel
exampleEasyNTMultiChannel_SRCS += exampleEasyNTMultiChannel.cpp
exampleEasyNTMultiChannel_LIBS += easyPVA
exampleEasyNTMultiChannel_LIBS += pvAccess
exampleEasyNTMultiChannel_LIBS += nt
exampleEasyNTMultiChannel_LIBS += pvData
exampleEasyNTMultiChannel_LIBS += Com
PROD_HOST += examplePvaClientNTMultiChannel
examplePvaClientNTMultiChannel_SRCS += examplePvaClientNTMultiChannel.cpp
examplePvaClientNTMultiChannel_LIBS += pvaClient
examplePvaClientNTMultiChannel_LIBS += pvAccess
examplePvaClientNTMultiChannel_LIBS += nt
examplePvaClientNTMultiChannel_LIBS += pvData
examplePvaClientNTMultiChannel_LIBS += Com
PROD_HOST += helloWorldRPC
helloWorldRPC_SRCS += helloWorldRPC.cpp
helloWorldRPC_LIBS += easyPVA
helloWorldRPC_LIBS += pvaClient
helloWorldRPC_LIBS += pvAccess
helloWorldRPC_LIBS += nt
helloWorldRPC_LIBS += pvData
@@ -58,7 +58,7 @@ helloWorldRPC_LIBS += Com
PROD_HOST += helloWorldPutGet
helloWorldPutGet_SRCS += helloWorldPutGet.cpp
helloWorldPutGet_LIBS += easyPVA
helloWorldPutGet_LIBS += pvaClient
helloWorldPutGet_LIBS += pvAccess
helloWorldPutGet_LIBS += nt
helloWorldPutGet_LIBS += pvData

90
example/src/exampleEasyGet.cpp → example/src/examplePvaClientGet.cpp
View File

@@ -1,4 +1,4 @@
/*exampleEasyGet.cpp */
/*examplePvaClientGet.cpp */
/**
* Copyright - See the COPYRIGHT that is included with this distribution.
* EPICS pvData is distributed subject to a Software License Agreement found
@@ -12,70 +12,70 @@
#include <iostream>
#include <pv/easyPVA.h>
#include <pv/pvaClient.h>
using namespace std;
using namespace epics::pvData;
using namespace epics::pvAccess;
using namespace epics::easyPVA;
using namespace epics::pvaClient;
static void exampleDouble(EasyPVAPtr const &easyPVA)
static void exampleDouble(PvaClientPtr const &pva)
{
cout << "example double scalar\n";
double value;
try {
cout << "short way\n";
value = easyPVA->channel("exampleDouble")->get()->getData()->getDouble();
value = pva->channel("exampleDouble")->get()->getData()->getDouble();
cout << "as double " << value << endl;
} catch (std::runtime_error e) {
cout << "exception " << e.what() << endl;
}
cout << "long way\n";
EasyChannelPtr easyChannel = easyPVA->createChannel("exampleDouble");
easyChannel->issueConnect();
Status status = easyChannel->waitConnect(2.0);
PvaClientChannelPtr pvaChannel = pva->createChannel("exampleDouble");
pvaChannel->issueConnect();
Status status = pvaChannel->waitConnect(2.0);
if(!status.isOK()) {cout << " connect failed\n"; return;}
EasyGetPtr easyGet = easyChannel->createGet();
easyGet->issueConnect();
status = easyGet->waitConnect();
PvaClientGetPtr pvaGet = pvaChannel->createGet();
pvaGet->issueConnect();
status = pvaGet->waitConnect();
if(!status.isOK()) {cout << " createGet failed\n"; return;}
EasyGetDataPtr easyData = easyGet->getData();
value = easyData->getDouble();
PvaClientGetDataPtr pvaData = pvaGet->getData();
value = pvaData->getDouble();
cout << "as double " << value << endl;
}
static void exampleDoubleArray(EasyPVAPtr const &easyPVA)
static void exampleDoubleArray(PvaClientPtr const &pva)
{
cout << "example double array\n";
shared_vector<const double> value;
try {
cout << "short way\n";
value = easyPVA->channel("exampleDoubleArray")->get()->getData()->getDoubleArray();
value = pva->channel("exampleDoubleArray")->get()->getData()->getDoubleArray();
cout << "as doubleArray " << value << endl;
} catch (std::runtime_error e) {
cout << "exception " << e.what() << endl;
}
try {
cout << "long way\n";
EasyChannelPtr easyChannel = easyPVA->createChannel("exampleDoubleArray");
easyChannel->connect(2.0);
EasyGetPtr easyGet = easyChannel->createGet();
EasyGetDataPtr easyData = easyGet->getData();
value = easyData->getDoubleArray();
PvaClientChannelPtr pvaChannel = pva->createChannel("exampleDoubleArray");
pvaChannel->connect(2.0);
PvaClientGetPtr pvaGet = pvaChannel->createGet();
PvaClientGetDataPtr pvaData = pvaGet->getData();
value = pvaData->getDoubleArray();
cout << "as doubleArray " << value << endl;
} catch (std::runtime_error e) {
cout << "exception " << e.what() << endl;
}
}
static void examplePowerSupply(EasyPVAPtr const &easyPVA)
static void examplePowerSupply(PvaClientPtr const &pva)
{
cout << "example powerSupply\n";
PVStructurePtr pvStructure;
try {
cout << "short way\n";
pvStructure = easyPVA->channel("examplePowerSupply")->
pvStructure = pva->channel("examplePowerSupply")->
get("field()")->getData()->getPVStructure();
cout << pvStructure << endl;
} catch (std::runtime_error e) {
@@ -84,49 +84,49 @@ static void examplePowerSupply(EasyPVAPtr const &easyPVA)
}
static void exampleCADouble(EasyPVAPtr const &easyPVA)
static void exampleCADouble(PvaClientPtr const &pva)
{
cout << "example double scalar\n";
double value;
try {
cout << "short way\n";
value = easyPVA->channel("double00","ca",5.0)->get()->getData()->getDouble();
value = pva->channel("double00","ca",5.0)->get()->getData()->getDouble();
cout << "as double " << value << endl;
} catch (std::runtime_error e) {
cout << "exception " << e.what() << endl;
}
cout << "long way\n";
EasyChannelPtr easyChannel = easyPVA->createChannel("double00","ca");
easyChannel->issueConnect();
Status status = easyChannel->waitConnect(2.0);
PvaClientChannelPtr pvaChannel = pva->createChannel("double00","ca");
pvaChannel->issueConnect();
Status status = pvaChannel->waitConnect(2.0);
if(!status.isOK()) {cout << " connect failed\n"; return;}
EasyGetPtr easyGet = easyChannel->createGet();
easyGet->issueConnect();
status = easyGet->waitConnect();
PvaClientGetPtr pvaGet = pvaChannel->createGet();
pvaGet->issueConnect();
status = pvaGet->waitConnect();
if(!status.isOK()) {cout << " createGet failed\n"; return;}
EasyGetDataPtr easyData = easyGet->getData();
value = easyData->getDouble();
PvaClientGetDataPtr pvaData = pvaGet->getData();
value = pvaData->getDouble();
cout << "as double " << value << endl;
}
static void exampleCADoubleArray(EasyPVAPtr const &easyPVA)
static void exampleCADoubleArray(PvaClientPtr const &pva)
{
cout << "example double array\n";
shared_vector<const double> value;
try {
cout << "short way\n";
value = easyPVA->channel("doubleArray","ca",5.0)->get()->getData()->getDoubleArray();
value = pva->channel("doubleArray","ca",5.0)->get()->getData()->getDoubleArray();
cout << "as doubleArray " << value << endl;
} catch (std::runtime_error e) {
cout << "exception " << e.what() << endl;
}
try {
cout << "long way\n";
EasyChannelPtr easyChannel = easyPVA->createChannel("doubleArray","ca");
easyChannel->connect(2.0);
EasyGetPtr easyGet = easyChannel->createGet();
EasyGetDataPtr easyData = easyGet->getData();
value = easyData->getDoubleArray();
PvaClientChannelPtr pvaChannel = pva->createChannel("doubleArray","ca");
pvaChannel->connect(2.0);
PvaClientGetPtr pvaGet = pvaChannel->createGet();
PvaClientGetDataPtr pvaData = pvaGet->getData();
value = pvaData->getDoubleArray();
cout << "as doubleArray " << value << endl;
} catch (std::runtime_error e) {
cout << "exception " << e.what() << endl;
@@ -135,12 +135,12 @@ static void exampleCADoubleArray(EasyPVAPtr const &easyPVA)
int main(int argc,char *argv[])
{
EasyPVAPtr easyPVA = EasyPVA::create();
exampleDouble(easyPVA);
exampleDoubleArray(easyPVA);
examplePowerSupply(easyPVA);
exampleCADouble(easyPVA);
exampleCADoubleArray(easyPVA);
PvaClientPtr pva= PvaClient::create();
exampleDouble(pva);
exampleDoubleArray(pva);
examplePowerSupply(pva);
exampleCADouble(pva);
exampleCADoubleArray(pva);
cout << "done\n";
return 0;
}

20
example/src/exampleEasyMonitor.cpp → example/src/examplePvaClientMonitor.cpp
View File

@@ -1,4 +1,4 @@
/*monitorPowerSupply.cpp */
/*examplePvaClientClientMonitor.cpp */
/**
* Copyright - See the COPYRIGHT that is included with this distribution.
* EPICS pvData is distributed subject to a Software License Agreement found
@@ -14,24 +14,24 @@
#include <iostream>
#include <pv/easyPVA.h>
#include <pv/pvaClient.h>
using namespace std;
using namespace epics::pvData;
using namespace epics::pvAccess;
using namespace epics::easyPVA;
using namespace epics::pvaClient;
static void exampleMonitor(EasyPVAPtr const &easyPVA)
static void exampleMonitor(PvaClientPtr const &pva)
{
EasyMonitorPtr monitor = easyPVA->channel("examplePowerSupply")->monitor("");
EasyMonitorDataPtr easyData = monitor->getData();
PvaClientMonitorPtr monitor = pva->channel("examplePowerSupply")->monitor("");
PvaClientMonitorDataPtr pvaData = monitor->getData();
while(true) {
monitor->waitEvent();
cout << "changed\n";
easyData->showChanged(cout);
pvaData->showChanged(cout);
cout << "overrun\n";
easyData->showOverrun(cout);
pvaData->showOverrun(cout);
monitor->releaseEvent();
}
}
@@ -39,8 +39,8 @@ static void exampleMonitor(EasyPVAPtr const &easyPVA)
int main(int argc,char *argv[])
{
EasyPVAPtr easyPVA = EasyPVA::create();
exampleMonitor(easyPVA);
PvaClientPtr pva = PvaClient::create();
exampleMonitor(pva);
cout << "done\n";
return 0;
}

20
example/src/exampleEasyMultiDouble.cpp → example/src/examplePvaClientMultiDouble.cpp
View File

@@ -1,4 +1,4 @@
/*exampleEasyMultiDouble.cpp */
/*examplePvaClientMultiDouble.cpp */
/**
* Copyright - See the COPYRIGHT that is included with this distribution.
* EPICS pvData is distributed subject to a Software License Agreement found
@@ -12,15 +12,15 @@
#include <iostream>
#include <pv/easyMultiDouble.h>
#include <pv/pvaClientMultiDouble.h>
using namespace std;
using namespace epics::pvData;
using namespace epics::pvAccess;
using namespace epics::easyPVA;
using namespace epics::pvaClient;
static void example(EasyPVAPtr const &easyPVA)
static void example(PvaClientPtr const &pva)
{
cout << "example multiDouble\n";
size_t num = 5;
@@ -33,7 +33,7 @@ static void example(EasyPVAPtr const &easyPVA)
PVStringArrayPtr pvNames =
getPVDataCreate()->createPVScalarArray<PVStringArray>();
pvNames->replace(freeze(channelNames));
EasyMultiDoublePtr multiDouble(EasyMultiDouble::create(easyPVA,pvNames));
PvaClientMultiDoublePtr multiDouble(PvaClientMultiDouble::create(pva,pvNames));
try {
shared_vector<double> data = multiDouble->get();
cout << "initial " << data << endl;
@@ -47,7 +47,7 @@ static void example(EasyPVAPtr const &easyPVA)
}
static void exampleCA(EasyPVAPtr const &easyPVA)
static void exampleCA(PvaClientPtr const &pva)
{
cout << "example multiDouble\n";
size_t num = 5;
@@ -60,7 +60,7 @@ static void exampleCA(EasyPVAPtr const &easyPVA)
PVStringArrayPtr pvNames =
getPVDataCreate()->createPVScalarArray<PVStringArray>();
pvNames->replace(freeze(channelNames));
EasyMultiDoublePtr multiDouble(EasyMultiDouble::create(easyPVA,pvNames,5.0,"ca"));
PvaClientMultiDoublePtr multiDouble(PvaClientMultiDouble::create(pva,pvNames,5.0,"ca"));
try {
shared_vector<double> data = multiDouble->get();
cout << "initial " << data << endl;
@@ -77,8 +77,8 @@ static void exampleCA(EasyPVAPtr const &easyPVA)
int main(int argc,char *argv[])
{
EasyPVAPtr easyPVA = EasyPVA::create();
example(easyPVA);
exampleCA(easyPVA);
PvaClientPtr pva = PvaClient::create();
example(pva);
exampleCA(pva);
return 0;
}

28
example/src/exampleEasyNTMultiChannel.cpp → example/src/examplePvaClientNTMultiChannel.cpp
View File

@@ -1,4 +1,4 @@
/*exampleEasyNTMultiChannel.cpp */
/*examplePvaClientNTMultiChannel.cpp */
/**
* Copyright - See the COPYRIGHT that is included with this distribution.
* EPICS pvData is distributed subject to a Software License Agreement found
@@ -12,16 +12,16 @@
#include <iostream>
#include <pv/easyNTMultiChannel.h>
#include <pv/pvaClientNTMultiChannel.h>
using namespace std;
using namespace epics::pvData;
using namespace epics::pvAccess;
using namespace epics::easyPVA;
using namespace epics::pvaClient;
using namespace epics::nt;
static void example(EasyPVAPtr const &easyPVA)
static void example(PvaClientPtr const &pva)
{
cout << "example ntMultiChannel\n";
size_t num = 5;
@@ -44,10 +44,10 @@ static void example(EasyPVAPtr const &easyPVA)
addNanoseconds() ->
addUserTag() ->
createStructure();
EasyNTMultiChannelPtr easy = EasyNTMultiChannel::create(
easyPVA,pvNames,structure);
PvaClientNTMultiChannelPtr multi = PvaClientNTMultiChannel::create(
pva,pvNames,structure);
try {
NTMultiChannelPtr nt = easy->get();
NTMultiChannelPtr nt = multi->get();
cout << "initial\n" << nt->getPVStructure() << endl;
} catch (std::runtime_error e) {
@@ -56,7 +56,7 @@ static void example(EasyPVAPtr const &easyPVA)
}
static void exampleCA(EasyPVAPtr const &easyPVA)
static void exampleCA(PvaClientPtr const &pva)
{
cout << "example ntMultiChannel\n";
size_t num = 5;
@@ -79,10 +79,10 @@ static void exampleCA(EasyPVAPtr const &easyPVA)
addNanoseconds() ->
addUserTag() ->
createStructure();
EasyNTMultiChannelPtr easy = EasyNTMultiChannel::create(
easyPVA,pvNames,structure,5.0,"ca");
PvaClientNTMultiChannelPtr multi = PvaClientNTMultiChannel::create(
pva,pvNames,structure,5.0,"ca");
try {
NTMultiChannelPtr nt = easy->get();
NTMultiChannelPtr nt = multi->get();
cout << "initial\n" << nt->getPVStructure() << endl;
} catch (std::runtime_error e) {
@@ -94,8 +94,8 @@ static void exampleCA(EasyPVAPtr const &easyPVA)
int main(int argc,char *argv[])
{
EasyPVAPtr easyPVA = EasyPVA::create();
example(easyPVA);
exampleCA(easyPVA);
PvaClientPtr pva = PvaClient::create();
example(pva);
exampleCA(pva);
return 0;
}

16
example/src/exampleEasyProcess.cpp → example/src/examplePvaClientProcess.cpp
View File

@@ -1,4 +1,4 @@
/*exampleEasyProcess.cpp */
/*examplePvaClientProcess.cpp */
/**
* Copyright - See the COPYRIGHT that is included with this distribution.
* EPICS pvData is distributed subject to a Software License Agreement found
@@ -12,19 +12,19 @@
#include <iostream>
#include <pv/easyPVA.h>
#include <pv/pvaClient.h>
using namespace std;
using namespace epics::pvData;
using namespace epics::pvAccess;
using namespace epics::easyPVA;
using namespace epics::pvaClient;
static void exampleProcess(EasyPVAPtr const &easyPVA)
static void exampleProcess(PvaClientPtr const &pva)
{
cout << "example process\n";
EasyChannelPtr channel = easyPVA->channel("exampleDouble");
EasyProcessPtr process = channel->createProcess();
PvaClientChannelPtr channel = pva->channel("exampleDouble");
PvaClientProcessPtr process = channel->createProcess();
try {
process->process();
cout << channel->get("field()")->getData()->showChanged(cout) << endl;
@@ -38,7 +38,7 @@ static void exampleProcess(EasyPVAPtr const &easyPVA)
int main(int argc,char *argv[])
{
EasyPVAPtr easyPVA = EasyPVA::create();
exampleProcess(easyPVA);
PvaClientPtr pva = PvaClient::create();
exampleProcess(pva);
return 0;
}

18
example/src/exampleEasyPut.cpp → example/src/examplePvaClientPut.cpp
View File

@@ -1,4 +1,4 @@
/*exampleEasyPut.cpp */
/*examplePvaClientPut.cpp */
/**
* Copyright - See the COPYRIGHT that is included with this distribution.
* EPICS pvData is distributed subject to a Software License Agreement found
@@ -12,20 +12,20 @@
#include <iostream>
#include <pv/easyPVA.h>
#include <pv/pvaClient.h>
using namespace std;
using namespace epics::pvData;
using namespace epics::pvAccess;
using namespace epics::easyPVA;
using namespace epics::pvaClient;
static void examplePut(EasyPVAPtr const &easyPVA)
static void examplePut(PvaClientPtr const &pva)
{
cout << "example put\n";
EasyChannelPtr channel = easyPVA->channel("exampleDouble");
EasyPutPtr put = channel->put();
EasyPutDataPtr putData = put->getData();
PvaClientChannelPtr channel = pva->channel("exampleDouble");
PvaClientPutPtr put = channel->put();
PvaClientPutDataPtr putData = put->getData();
try {
putData->putDouble(3.0); put->put();
cout << channel->get("field()")->getData()->showChanged(cout) << endl;
@@ -39,7 +39,7 @@ static void examplePut(EasyPVAPtr const &easyPVA)
int main(int argc,char *argv[])
{
EasyPVAPtr easyPVA = EasyPVA::create();
examplePut(easyPVA);
PvaClientPtr pva = PvaClient::create();
examplePut(pva);
return 0;
}

18
example/src/helloWorldPutGet.cpp
View File

@@ -12,27 +12,27 @@
#include <iostream>
#include <pv/easyPVA.h>
#include <pv/pvaClient.h>
using namespace std;
using namespace epics::pvData;
using namespace epics::pvAccess;
using namespace epics::easyPVA;
using namespace epics::pvaClient;
static void example(EasyPVAPtr const &easyPVA)
static void example(PvaClientPtr const &pva)
{
cout << "helloWorldPutGet\n";
try {
EasyChannelPtr channel = easyPVA->channel("exampleHello");
EasyPutGetPtr putGet = channel->createPutGet();
PvaClientChannelPtr channel = pva->channel("exampleHello");
PvaClientPutGetPtr putGet = channel->createPutGet();
putGet->connect();
EasyPutDataPtr putData = putGet->getPutData();
PvaClientPutDataPtr putData = putGet->getPutData();
PVStructurePtr arg = putData->getPVStructure();
PVStringPtr pvValue = arg->getSubField<PVString>("argument.value");
pvValue->put("World");
putGet->putGet();
EasyGetDataPtr getData = putGet->getGetData();
PvaClientGetDataPtr getData = putGet->getGetData();
cout << getData->getPVStructure() << endl;
} catch (std::runtime_error e) {
cout << "exception " << e.what() << endl;
@@ -42,7 +42,7 @@ static void example(EasyPVAPtr const &easyPVA)
int main(int argc,char *argv[])
{
EasyPVAPtr easyPVA = EasyPVA::create();
example(easyPVA);
PvaClientPtr pva = PvaClient::create();
example(pva);
return 0;
}

2
example/src/helloWorldRPC.cpp
View File

@@ -1,4 +1,4 @@
/*exampleChannelRPC.cpp */
/*helloWorldRPC.cpp */
/**
* Copyright - See the COPYRIGHT that is included with this distribution.
* EPICS pvData is distributed subject to a Software License Agreement found

0
exampleDatabaseEasyPVA.zip → exampleDatabasePvaClient.zip
View File

6
jenkins/cloudbees_build
View File

@@ -1,4 +1,4 @@
# easyPVA C++ implementation
# pvaClient C++ implementation
# Jenkins @ Cloudbees build script
#
# Jenkins invokes scripts with the "-ex" option. So the build is considered a failure
@@ -68,11 +68,11 @@ make runtests
###########################################
# Create distribution
tar --exclude=test* -czf easyPVA.CB-dist.tar.gz lib include
tar --exclude=test* -czf pvaClient.CB-dist.tar.gz lib include
###########################################
# Publish documentation
if [ "${BUILD_DOCS}" ]; then
rsync -aqP --delete -e ssh documentation epics-jenkins@web.sourceforge.net:/home/project-web/epics-pvdata/htdocs/docbuild/easyPVACPP/tip
rsync -aqP --delete -e ssh documentation epics-jenkins@web.sourceforge.net:/home/project-web/epics-pvdata/htdocs/docbuild/pvaClientCPP/tip
fi

39
src/Makefile
View File

@@ -3,29 +3,28 @@
TOP = ..
include $(TOP)/configure/CONFIG
LIBRARY += easyPVA
LIBRARY += pvaClient
INC += easyPVA.h
INC += easyMultiDouble.h
INC += easyNTMultiChannel.h
INC += pvaClient.h
INC += pvaClientMultiDouble.h
INC += pvaClientNTMultiChannel.h
LIBSRCS += easyPVA.cpp
LIBSRCS += easyPutData.cpp
LIBSRCS += easyGetData.cpp
LIBSRCS += easyMonitorData.cpp
LIBSRCS += easyChannel.cpp
LIBSRCS += easyProcess.cpp
LIBSRCS += easyGet.cpp
LIBSRCS += easyPut.cpp
LIBSRCS += easyMonitor.cpp
LIBSRCS += easyPutGet.cpp
LIBSRCS += easyMultiChannel.cpp
LIBSRCS += easyMultiDouble.cpp
LIBSRCS += easyNTMultiChannel.cpp
#LIBSRCS += easyRPC.cpp
LIBSRCS += pvaClient.cpp
LIBSRCS += pvaClientPutData.cpp
LIBSRCS += pvaClientGetData.cpp
LIBSRCS += pvaClientMonitorData.cpp
LIBSRCS += pvaClientChannel.cpp
LIBSRCS += pvaClientProcess.cpp
LIBSRCS += pvaClientGet.cpp
LIBSRCS += pvaClientPut.cpp
LIBSRCS += pvaClientMonitor.cpp
LIBSRCS += pvaClientPutGet.cpp
LIBSRCS += pvaClientMultiChannel.cpp
LIBSRCS += pvaClientMultiDouble.cpp
LIBSRCS += pvaClientNTMultiChannel.cpp
easyPVA_LIBS += pvAccess pvData nt Com
easyPVA_LIBS += $(EPICS_BASE_IOC_LIBS)
pvaClient_LIBS += pvAccess pvData nt Com
pvaClient_LIBS += $(EPICS_BASE_IOC_LIBS)
include $(TOP)/configure/RULES

495
src/easyChannel.cpp
View File

@@ -1,495 +0,0 @@
/* easyChannel.cpp */
/**
* Copyright - See the COPYRIGHT that is included with this distribution.
* EPICS pvData is distributed subject to a Software License Agreement found
* in file LICENSE that is included with this distribution.
*/
/**
* @author mrk
* @date 2015.02
*/
#define epicsExportSharedSymbols
#include <map>
#include <sstream>
#include <pv/event.h>
#include <pv/lock.h>
#include <pv/easyPVA.h>
#include <pv/createRequest.h>
using std::tr1::static_pointer_cast;
using namespace epics::pvData;
using namespace epics::pvAccess;
using namespace std;
namespace epics { namespace easyPVA {
class EasyGetCache
{
public:
EasyGetCache(){}
~EasyGetCache();
void destroy() {
easyGetMap.clear();
}
EasyGetPtr getGet(string const & request);
void addGet(string const & request,EasyGetPtr const & easyGet);
private:
map<string,EasyGetPtr> easyGetMap;
};
EasyGetCache::~EasyGetCache()
{
destroy();
}
EasyGetPtr EasyGetCache::getGet(string const & request)
{
map<string,EasyGetPtr>::iterator iter = easyGetMap.find(request);
if(iter!=easyGetMap.end()) return iter->second;
return EasyGetPtr();
}
void EasyGetCache::addGet(string const & request,EasyGetPtr const & easyGet)
{
easyGetMap.insert(std::pair<string,EasyGetPtr>(
request,easyGet));
}
class EasyPutCache
{
public:
EasyPutCache(){}
~EasyPutCache();
void destroy() {
easyPutMap.clear();
}
EasyPutPtr getPut(string const & request);
void addPut(string const & request,EasyPutPtr const & easyPut);
private:
map<string,EasyPutPtr> easyPutMap;
};
EasyPutCache::~EasyPutCache()
{
destroy();
}
EasyPutPtr EasyPutCache::getPut(string const & request)
{
map<string,EasyPutPtr>::iterator iter = easyPutMap.find(request);
if(iter!=easyPutMap.end()) return iter->second;
return EasyPutPtr();
}
void EasyPutCache::addPut(string const & request,EasyPutPtr const & easyPut)
{
easyPutMap.insert(std::pair<string,EasyPutPtr>(
request,easyPut));
}
class ChannelRequesterImpl : public ChannelRequester
{
EasyChannel *easyChannel;
public:
ChannelRequesterImpl(EasyChannel *easyChannel)
: easyChannel(easyChannel) {}
void channelCreated(
const Status& status,
Channel::shared_pointer const & channel)
{ easyChannel->channelCreated(status,channel); }
void channelStateChange(
Channel::shared_pointer const & channel,
Channel::ConnectionState connectionState)
{easyChannel->channelStateChange(channel,connectionState);}
tr1::shared_ptr<Channel> getChannel() {return easyChannel->getChannel();}
string getRequesterName()
{return easyChannel->getRequesterName();}
void message(
string const & message,
MessageType messageType)
{ easyChannel->message(message,messageType); }
void destroy() {easyChannel->destroy();}
};
EasyChannel::EasyChannel(
EasyPVAPtr const &easyPVA,
string const & channelName,
string const & providerName)
: easyPVA(easyPVA),
channelName(channelName),
providerName(providerName),
connectState(connectIdle),
isDestroyed(false),
createRequest(CreateRequest::create()),
easyGetCache(new EasyGetCache()),
easyPutCache(new EasyPutCache())
{}
EasyChannel::~EasyChannel()
{
destroy();
}
void EasyChannel::channelCreated(const Status& status, Channel::shared_pointer const & channel)
{
if(isDestroyed) throw std::runtime_error("easyChannel was destroyed");
if(status.isOK()) {
this->channel = channel;
return;
}
cout << "EasyChannel::channelCreated status " << status.getMessage() << " why??\n";
}
void EasyChannel::channelStateChange(
Channel::shared_pointer const & channel,
Channel::ConnectionState connectionState)
{
if(isDestroyed) return;
bool waitingForConnect = false;
if(connectState==connectActive) waitingForConnect = true;
if(connectionState!=Channel::CONNECTED) {
string mess(channelName +
" connection state " + Channel::ConnectionStateNames[connectionState]);
message(mess,errorMessage);
channelConnectStatus = Status(Status::STATUSTYPE_ERROR,mess);
connectState = notConnected;
} else {
connectState = connected;
}
if(waitingForConnect) waitForConnect.signal();
}
string EasyChannel::getRequesterName()
{
EasyPVAPtr yyy = easyPVA.lock();
if(!yyy) throw std::runtime_error("EasyPVA was destroyed");
return yyy->getRequesterName();
}
void EasyChannel::message(
string const & message,
MessageType messageType)
{
if(isDestroyed) throw std::runtime_error("easyChannel was destroyed");
EasyPVAPtr yyy = easyPVA.lock();
if(!yyy) throw std::runtime_error("EasyPVA was destroyed");
yyy->message(message, messageType);
}
void EasyChannel::destroy()
{
{
Lock xx(mutex);
if(isDestroyed) return;
isDestroyed = true;
}
if(channel) channel->destroy();
channel.reset();
easyGetCache.reset();
easyPutCache.reset();
}
string EasyChannel::getChannelName()
{
if(isDestroyed) throw std::runtime_error("easyChannel was destroyed");
return channelName;
}
Channel::shared_pointer EasyChannel::getChannel()
{
if(isDestroyed) throw std::runtime_error("easyChannel was destroyed");
return channel;
}
void EasyChannel::connect(double timeout)
{
if(isDestroyed) throw std::runtime_error("easyChannel was destroyed");
issueConnect();
Status status = waitConnect(timeout);
if(status.isOK()) return;
stringstream ss;
ss << "channel " << getChannelName() << " EasyChannel::connect " << status.getMessage();
throw std::runtime_error(ss.str());
}
void EasyChannel::issueConnect()
{
if(isDestroyed) throw std::runtime_error("easyChannel was destroyed");
if(connectState!=connectIdle) {
throw std::runtime_error("easyChannel already connected");
}
channelRequester = ChannelRequester::shared_pointer(new ChannelRequesterImpl(this));
channelConnectStatus = Status(
Status::STATUSTYPE_ERROR,
getChannelName() + " createChannel failed");
connectState = connectActive;
ChannelProviderRegistry::shared_pointer reg = getChannelProviderRegistry();
ChannelProvider::shared_pointer provider = reg->getProvider(providerName);
if(!provider) {
throw std::runtime_error(getChannelName() + " provider " + providerName + " not registered");
}
channel = provider->createChannel(channelName,channelRequester,ChannelProvider::PRIORITY_DEFAULT);
if(!channel) {
throw std::runtime_error(channelConnectStatus.getMessage());
}
}
Status EasyChannel::waitConnect(double timeout)
{
if(isDestroyed) throw std::runtime_error("easyChannel was destroyed");
waitForConnect.wait(timeout);
if(connectState==connected) return Status::Ok;
return Status(Status::STATUSTYPE_ERROR,channelConnectStatus.getMessage());
}
EasyFieldPtr EasyChannel::createField()
{
return createField("");
}
EasyFieldPtr EasyChannel::createField(string const & subField)
{
throw std::runtime_error("EasyChannel::createField not implemented");
}
EasyProcessPtr EasyChannel::createProcess()
{
return createProcess("");
}
EasyProcessPtr EasyChannel::createProcess(string const & request)
{
PVStructurePtr pvRequest = createRequest->createRequest(request);
if(!pvRequest) {
stringstream ss;
ss << "channel " << getChannelName();
ss << " EasyChannel::createProcess invalid pvRequest: " + createRequest->getMessage();
throw std::runtime_error(ss.str());
}
return createProcess(pvRequest);
}
EasyProcessPtr EasyChannel::createProcess(PVStructurePtr const & pvRequest)
{
if(connectState!=connected) connect(5.0);
if(connectState!=connected) throw std::runtime_error("EasyChannel::creatProcess not connected");
EasyPVAPtr yyy = easyPVA.lock();
if(!yyy) throw std::runtime_error("EasyPVA was destroyed");
return EasyProcess::create(yyy,getPtrSelf(),channel,pvRequest);
}
EasyGetPtr EasyChannel::get() {return get("value,alarm,timeStamp");}
EasyGetPtr EasyChannel::get(string const & request)
{
EasyGetPtr easyGet = easyGetCache->getGet(request);
if(easyGet) return easyGet;
easyGet = createGet(request);
easyGet->connect();
easyGetCache->addGet(request,easyGet);
return easyGet;
}
EasyGetPtr EasyChannel::createGet()
{
return EasyChannel::createGet("value,alarm,timeStamp");
}
EasyGetPtr EasyChannel::createGet(string const & request)
{
PVStructurePtr pvRequest = createRequest->createRequest(request);
if(!pvRequest) {
stringstream ss;
ss << "channel " << getChannelName();
ss << " EasyChannel::createGet invalid pvRequest: " + createRequest->getMessage();
throw std::runtime_error(ss.str());
}
return createGet(pvRequest);
}
EasyGetPtr EasyChannel::createGet(PVStructurePtr const & pvRequest)
{
if(connectState!=connected) connect(5.0);
if(connectState!=connected) throw std::runtime_error("EasyChannel::creatGet not connected");
EasyPVAPtr yyy = easyPVA.lock();
if(!yyy) throw std::runtime_error("EasyPVA was destroyed");
return EasyGet::create(yyy,getPtrSelf(),channel,pvRequest);
}
EasyPutPtr EasyChannel::put() {return put("value");}
EasyPutPtr EasyChannel::put(string const & request)
{
EasyPutPtr easyPut = easyPutCache->getPut(request);
if(easyPut) return easyPut;
easyPut = createPut(request);
easyPut->connect();
easyPut->get();
easyPutCache->addPut(request,easyPut);
return easyPut;
}
EasyPutPtr EasyChannel::createPut()
{
return createPut("value");
}
EasyPutPtr EasyChannel::createPut(string const & request)
{
PVStructurePtr pvRequest = createRequest->createRequest(request);
if(!pvRequest) {
stringstream ss;
ss << "channel " << getChannelName();
ss << " EasyChannel::createPut invalid pvRequest: " + createRequest->getMessage();
throw std::runtime_error(ss.str());
}
return createPut(pvRequest);
}
EasyPutPtr EasyChannel::createPut(PVStructurePtr const & pvRequest)
{
if(connectState!=connected) connect(5.0);
if(connectState!=connected) throw std::runtime_error("EasyChannel::creatPut not connected");
EasyPVAPtr yyy = easyPVA.lock();
if(!yyy) throw std::runtime_error("EasyPVA was destroyed");
return EasyPut::create(yyy,getPtrSelf(),channel,pvRequest);
}
EasyPutGetPtr EasyChannel::createPutGet()
{
return createPutGet("putField(argument)getField(result)");
}
EasyPutGetPtr EasyChannel::createPutGet(string const & request)
{
PVStructurePtr pvRequest = createRequest->createRequest(request);
if(!pvRequest) {
stringstream ss;
ss << "channel " << getChannelName();
ss << " EasyChannel::createPutGet invalid pvRequest: " + createRequest->getMessage();
throw std::runtime_error(ss.str());
}
return createPutGet(pvRequest);
}
EasyPutGetPtr EasyChannel::createPutGet(PVStructurePtr const & pvRequest)
{
if(connectState!=connected) connect(5.0);
if(connectState!=connected) throw std::runtime_error("EasyChannel::creatPutGet not connected");
EasyPVAPtr yyy = easyPVA.lock();
if(!yyy) throw std::runtime_error("EasyPVA was destroyed");
return EasyPutGet::create(yyy,getPtrSelf(),channel,pvRequest);
}
EasyRPCPtr EasyChannel::createRPC()
{
return createRPC("");
}
EasyRPCPtr EasyChannel::createRPC(string const & request)
{
PVStructurePtr pvRequest = createRequest->createRequest(request);
if(!pvRequest) {
stringstream ss;
ss << "channel " << getChannelName();
ss << " EasyChannel::createRPC invalid pvRequest: " + createRequest->getMessage();
throw std::runtime_error(ss.str());
}
return createRPC(pvRequest);
}
EasyRPCPtr EasyChannel::createRPC(PVStructurePtr const & pvRequest)
{
throw std::runtime_error("EasyChannel::createRPC not implemented");
}
EasyArrayPtr EasyChannel::createArray()
{
return createArray("value");
}
EasyArrayPtr EasyChannel::createArray(string const & request)
{
PVStructurePtr pvRequest = createRequest->createRequest(request);
if(!pvRequest) {
stringstream ss;
ss << "channel " << getChannelName();
ss << " EasyChannel::createArray invalid pvRequest: " + createRequest->getMessage();
throw std::runtime_error(ss.str());
}
return createArray(pvRequest);
}
EasyArrayPtr EasyChannel::createArray(PVStructurePtr const & pvRequest)
{
throw std::runtime_error("EasyChannel::createArray not implemented");
}
EasyMonitorPtr EasyChannel::monitor() {return monitor("value,alarm,timeStamp");}
EasyMonitorPtr EasyChannel::monitor(string const & request)
{
EasyMonitorPtr easyMonitor = createMonitor(request);
easyMonitor->connect();
easyMonitor->start();
return easyMonitor;
}
EasyMonitorPtr EasyChannel::monitor(EasyMonitorRequesterPtr const & easyMonitorRequester)
{ return monitor("value,alarm,timeStamp",easyMonitorRequester);
}
EasyMonitorPtr EasyChannel::monitor(string const & request,
EasyMonitorRequesterPtr const & easyMonitorRequester)
{
EasyMonitorPtr easyMonitor = createMonitor(request);
easyMonitor->connect();
easyMonitor->setRequester(easyMonitorRequester);
easyMonitor->start();
return easyMonitor;
}
EasyMonitorPtr EasyChannel::createMonitor()
{
return createMonitor("value,alarm,timeStamp");
}
EasyMonitorPtr EasyChannel::createMonitor(string const & request)
{
PVStructurePtr pvRequest = createRequest->createRequest(request);
if(!pvRequest) {
stringstream ss;
ss << "channel " << getChannelName();
ss << " EasyChannel::createMonitor invalid pvRequest: " + createRequest->getMessage();
throw std::runtime_error(ss.str());
}
return createMonitor(pvRequest);
}
EasyMonitorPtr EasyChannel::createMonitor(PVStructurePtr const & pvRequest)
{
if(connectState!=connected) connect(5.0);
if(connectState!=connected) throw std::runtime_error("EasyChannel::createMonitor not connected");
EasyPVAPtr yyy = easyPVA.lock();
if(!yyy) throw std::runtime_error("EasyPVA was destroyed");
return EasyMonitor::create(yyy,getPtrSelf(),channel,pvRequest);
}
EasyChannelPtr EasyChannel::create(
EasyPVAPtr const &easyPVA,
string const & channelName,
string const & providerName)
{
EasyChannelPtr channel(new EasyChannel(easyPVA,channelName,providerName));
return channel;
}
}}

250
src/easyMonitor.cpp
View File

@@ -1,250 +0,0 @@
/* easyMonitor.cpp */
/**
* Copyright - See the COPYRIGHT that is included with this distribution.
* EPICS pvData is distributed subject to a Software License Agreement found
* in file LICENSE that is included with this distribution.
*/
/**
* @author mrk
* @date 2015.03
*/
#define epicsExportSharedSymbols
#include <sstream>
#include <pv/event.h>
#include <pv/easyPVA.h>
#include <pv/bitSetUtil.h>
using std::tr1::static_pointer_cast;
using namespace epics::pvData;
using namespace epics::pvAccess;
using namespace std;
namespace epics { namespace easyPVA {
class ChannelMonitorRequester : public MonitorRequester
{
EasyMonitor * easyMonitor;
public:
ChannelMonitorRequester(EasyMonitor * easyMonitor)
: easyMonitor(easyMonitor) {}
string getRequesterName()
{return easyMonitor->getRequesterName();}
void message(string const & message,MessageType messageType)
{easyMonitor->message(message,messageType);}
void monitorConnect(
const Status& status,
Monitor::shared_pointer const & monitor,
StructureConstPtr const & structure)
{easyMonitor->monitorConnect(status,monitor,structure);}
void monitorEvent(MonitorPtr const & monitor)
{
easyMonitor->monitorEvent(monitor);
}
void unlisten(MonitorPtr const & monitor)
{easyMonitor->unlisten();}
};
EasyMonitor::EasyMonitor(
EasyPVAPtr const &pva,
EasyChannelPtr const & easyChannel,
Channel::shared_pointer const & channel,
PVStructurePtr const &pvRequest)
: easyPVA(pva),
easyChannel(easyChannel),
channel(channel),
pvRequest(pvRequest),
isDestroyed(false),
connectState(connectIdle),
userPoll(false),
userWait(false)
{
}
EasyMonitor::~EasyMonitor()
{
destroy();
}
void EasyMonitor::checkMonitorState()
{
if(isDestroyed) throw std::runtime_error("easyMonitor was destroyed");
if(connectState==connectIdle) connect();
if(connectState==connected) start();
}
// from MonitorRequester
string EasyMonitor::getRequesterName()
{
EasyPVAPtr yyy = easyPVA.lock();
if(!yyy) throw std::runtime_error("easyPVA was destroyed");
return yyy->getRequesterName();
}
void EasyMonitor::message(string const & message,MessageType messageType)
{
if(isDestroyed) throw std::runtime_error("easyMonitor was destroyed");
EasyPVAPtr yyy = easyPVA.lock();
if(!yyy) throw std::runtime_error("easyPVA was destroyed");
yyy->message(message, messageType);
}
void EasyMonitor::monitorConnect(
const Status& status,
Monitor::shared_pointer const & monitor,
StructureConstPtr const & structure)
{
if(isDestroyed) throw std::runtime_error("easyMonitor was destroyed");
connectStatus = status;
this->monitor = monitor;
if(status.isOK()) {
easyData = EasyMonitorData::create(structure);
easyData->setMessagePrefix(channel->getChannelName());
}
waitForConnect.signal();
}
void EasyMonitor::monitorEvent(MonitorPtr const & monitor)
{
EasyMonitorRequesterPtr req = easyMonitorRequester.lock();
if(req) req->event(getPtrSelf());
if(userWait) waitForEvent.signal();
}
void EasyMonitor::unlisten()
{
destroy();
}
// from EasyMonitor
void EasyMonitor::destroy()
{
{
Lock xx(mutex);
if(isDestroyed) return;
isDestroyed = true;
}
if(monitor) monitor->destroy();
monitor.reset();
}
void EasyMonitor::connect()
{
if(isDestroyed) throw std::runtime_error("easyMonitor was destroyed");
issueConnect();
Status status = waitConnect();
if(status.isOK()) return;
stringstream ss;
ss << "channel " << channel->getChannelName() << " EasyMonitor::connect " << status.getMessage();
throw std::runtime_error(ss.str());
}
void EasyMonitor::issueConnect()
{
if(isDestroyed) throw std::runtime_error("easyMonitor was destroyed");
if(connectState!=connectIdle) {
stringstream ss;
ss << "channel " << channel->getChannelName() << " easyMonitor already connected ";
throw std::runtime_error(ss.str());
}
monitorRequester = ChannelMonitorRequester::shared_pointer(new ChannelMonitorRequester(this));
connectState = connectActive;
monitor = channel->createMonitor(monitorRequester,pvRequest);
}
Status EasyMonitor::waitConnect()
{
if(isDestroyed) throw std::runtime_error("easyMonitor was destroyed");
if(connectState!=connectActive) {
stringstream ss;
ss << "channel " << channel->getChannelName() << " easyMonitor illegal connect state ";
throw std::runtime_error(ss.str());
}
waitForConnect.wait();
if(connectStatus.isOK()){
connectState = connected;
return Status::Ok;
}
connectState = connectIdle;
return Status(Status::STATUSTYPE_ERROR,connectStatus.getMessage());
}
void EasyMonitor::setRequester(EasyMonitorRequesterPtr const & easyMonitorrRequester)
{
this->easyMonitorRequester = easyMonitorrRequester;
}
void EasyMonitor::start()
{
if(isDestroyed) throw std::runtime_error("easyMonitor was destroyed");
if(connectState==monitorStarted) return;
if(connectState==connectIdle) connect();
if(connectState!=connected) throw std::runtime_error("EasyMonitor::start illegal state");
connectState = monitorStarted;
monitor->start();
}
void EasyMonitor::stop()
{
if(isDestroyed) throw std::runtime_error("easyMonitor was destroyed");
if(connectState!=monitorStarted) return;
connectState = connected;
monitor->stop();
}
bool EasyMonitor::poll()
{
checkMonitorState();
if(connectState!=monitorStarted) throw std::runtime_error("EasyMonitor::poll illegal state");
if(userPoll) throw std::runtime_error("EasyMonitor::poll did not release last");
monitorElement = monitor->poll();
if(!monitorElement) return false;
userPoll = true;
easyData->setData(monitorElement);
return true;
}
bool EasyMonitor::waitEvent(double secondsToWait)
{
if(isDestroyed) throw std::runtime_error("easyMonitor was destroyed");
if(connectState!=monitorStarted) throw std::runtime_error("EasyMonitor::poll illegal state");
if(poll()) return true;
userWait = true;
if(secondsToWait==0.0) {
waitForEvent.wait();
} else {
waitForEvent.wait(secondsToWait);
}
userWait = false;
return poll();
}
void EasyMonitor::releaseEvent()
{
if(isDestroyed) throw std::runtime_error("easyMonitor was destroyed");
if(connectState!=monitorStarted) throw std::runtime_error("EasyMonitor::poll illegal state");
if(!userPoll) throw std::runtime_error("EasyMonitor::releaseEvent did not call poll");
userPoll = false;
monitor->release(monitorElement);
}
EasyMonitorDataPtr EasyMonitor::getData()
{
checkMonitorState();
return easyData;
}
EasyMonitorPtr EasyMonitor::create(
EasyPVAPtr const &pva,
EasyChannelPtr const & easyChannel,
Channel::shared_pointer const & channel,
PVStructurePtr const &pvRequest)
{
EasyMonitorPtr epv(new EasyMonitor(pva,easyChannel,channel,pvRequest));
return epv;
}
}}

165
src/easyMultiChannel.cpp
View File

@@ -1,165 +0,0 @@
/* easyMultiChannel.cpp */
/**
* Copyright - See the COPYRIGHT that is included with this distribution.
* EPICS pvData is distributed subject to a Software License Agreement found
* in file LICENSE that is included with this distribution.
*/
/**
* @author mrk
* @date 2015.02
*/
#define epicsExportSharedSymbols
#include <map>
#include <sstream>
#include <pv/event.h>
#include <pv/lock.h>
#include <pv/easyPVA.h>
#include <pv/createRequest.h>
using std::tr1::static_pointer_cast;
using namespace epics::pvData;
using namespace epics::pvAccess;
using namespace std;
namespace epics { namespace easyPVA {
EasyMultiChannel::EasyMultiChannel(
EasyPVAPtr const &easyPVA,
PVStringArrayPtr const & channelName,
string const & providerName)
: easyPVA(easyPVA),
channelName(channelName),
providerName(providerName),
numChannel(channelName->getLength()),
isConnected(getPVDataCreate()->createPVScalarArray<PVBooleanArray>()),
isDestroyed(false)
{
}
EasyMultiChannel::~EasyMultiChannel()
{
destroy();
}
void EasyMultiChannel::destroy()
{
{
Lock xx(mutex);
if(isDestroyed) return;
isDestroyed = true;
}
easyChannelArray.reset();
}
PVStringArrayPtr EasyMultiChannel::getChannelNames()
{
if(isDestroyed) throw std::runtime_error("easyMultiChannel was destroyed");
return channelName;
}
Status EasyMultiChannel::connect(double timeout,size_t maxNotConnected)
{
if(isDestroyed) throw std::runtime_error("easyMultiChannel was destroyed");
if(easyChannelArray) throw std::runtime_error("easyMultiChannel already connected");
EasyPVAPtr easy = easyPVA.lock();
if(!easy) return Status(Status::STATUSTYPE_ERROR,"easyPVA is gone");
shared_vector<EasyChannelPtr> easyChannel(numChannel,EasyChannelPtr());
PVStringArray::const_svector channelNames = channelName->view();
shared_vector<boolean> isConnected(numChannel,false);
for(size_t i=0; i< numChannel; ++i) {
easyChannel[i] = easy->createChannel(channelNames[i],providerName);
easyChannel[i]->issueConnect();
}
Status returnStatus = Status::Ok;
Status status = Status::Ok;
size_t numBad = 0;
for(size_t i=0; i< numChannel; ++i) {
if(numBad==0) {
status = easyChannel[i]->waitConnect(timeout);
} else {
status = easyChannel[i]->waitConnect(.001);
}
if(status.isOK()) {
++numConnected;
isConnected[i] = true;
continue;
}
if(returnStatus.isOK()) returnStatus = status;
++numBad;
if(numBad>maxNotConnected) break;
}
easyChannelArray = EasyChannelArrayPtr(new EasyChannelArray(freeze(easyChannel)));
this->isConnected->replace(freeze(isConnected));
return numBad>maxNotConnected ? returnStatus : Status::Ok;
}
bool EasyMultiChannel::allConnected()
{
if(isDestroyed) throw std::runtime_error("easyMultiChannel was destroyed");
if(!easyChannelArray) throw std::runtime_error("easyMultiChannel not connected");
if(numConnected==numChannel) return true;
return (numConnected==numChannel) ? true : false;
}
bool EasyMultiChannel::connectionChange()
{
if(isDestroyed) throw std::runtime_error("easyMultiChannel was destroyed");
if(!easyChannelArray) throw std::runtime_error("easyMultiChannel not connected");
if(numConnected==numChannel) return true;
PVBooleanArray::const_svector isConnected = this->isConnected->view();
shared_vector<const EasyChannelPtr> channels = *easyChannelArray.get();
for(size_t i=0; i<numChannel; ++i) {
const EasyChannelPtr easyChannel = channels[i];
Channel::shared_pointer channel = easyChannel->getChannel();
Channel::ConnectionState stateNow = channel->getConnectionState();
bool connectedNow = stateNow==Channel::CONNECTED ? true : false;
if(connectedNow!=isConnected[i]) return true;
}
return false;
}
PVBooleanArrayPtr EasyMultiChannel::getIsConnected()
{
if(isDestroyed) throw std::runtime_error("easyMultiChannel was destroyed");
if(!easyChannelArray) throw std::runtime_error("easyMultiChannel not connected");
if(!connectionChange()) return isConnected;
shared_vector<boolean> isConnected(numChannel,false);
shared_vector<const EasyChannelPtr> channels = *easyChannelArray.get();
for(size_t i=0; i<numChannel; ++i) {
const EasyChannelPtr easyChannel = channels[i];
Channel::shared_pointer channel = easyChannel->getChannel();
Channel::ConnectionState stateNow = channel->getConnectionState();
if(stateNow==Channel::CONNECTED) isConnected[i] = true;
}
this->isConnected->replace(freeze(isConnected));
return this->isConnected;
}
EasyChannelArrayWPtr EasyMultiChannel::getEasyChannelArray()
{
if(isDestroyed) throw std::runtime_error("easyMultiChannel was destroyed");
if(!easyChannelArray) throw std::runtime_error("easyMultiChannel not connected");
return easyChannelArray;
}
EasyPVA::weak_pointer EasyMultiChannel::getEasyPVA()
{
if(isDestroyed) throw std::runtime_error("easyMultiChannel was destroyed");
return easyPVA;
}
EasyMultiChannelPtr EasyMultiChannel::create(
EasyPVAPtr const &easyPVA,
PVStringArrayPtr const & channelNames,
string const & providerName)
{
EasyMultiChannelPtr channel(new EasyMultiChannel(easyPVA,channelNames,providerName));
return channel;
}
}}

138
src/easyMultiDouble.cpp
View File

@@ -1,138 +0,0 @@
/* easyMultiDouble.cpp */
/**
* Copyright - See the COPYRIGHT that is included with this distribution.
* EPICS pvData is distributed subject to a Software License Agreement found
* in file LICENSE that is included with this distribution.
*/
/**
* @author mrk
* @date 2015.03
*/
#include <pv/easyMultiDouble.h>
using std::tr1::static_pointer_cast;
using namespace epics::pvData;
using namespace epics::pvAccess;
using namespace std;
namespace epics { namespace easyPVA {
EasyMultiDoublePtr EasyMultiDouble::create(
EasyPVAPtr const & easyPVA,
PVStringArrayPtr const & channelName,
double timeout,
std::string const & providerName)
{
EasyMultiChannelPtr easyMultiChannel(
EasyMultiChannel::create(easyPVA,channelName,providerName));
Status status = easyMultiChannel->connect(timeout,0);
if(!status.isOK()) throw std::runtime_error(status.getMessage());
return EasyMultiDoublePtr(new EasyMultiDouble(easyMultiChannel));
}
EasyMultiDouble::EasyMultiDouble(EasyMultiChannelPtr const &easyMultiChannel)
:
easyMultiChannel(easyMultiChannel)
{}
EasyMultiDouble::~EasyMultiDouble()
{
}
void EasyMultiDouble::createGet()
{
EasyChannelArrayPtr easyChannelArray = easyMultiChannel->getEasyChannelArray().lock();
if(!easyChannelArray) throw std::runtime_error("easyChannelArray is gone");
shared_vector<const EasyChannelPtr> easyChannels = *easyChannelArray;
size_t numChannel = easyChannels.size();
easyGet = std::vector<EasyGetPtr>(numChannel,EasyGetPtr());
bool allOK = true;
string message;
for(size_t i=0; i<numChannel; ++i)
{
easyGet[i] = easyChannels[i]->createGet("value");
easyGet[i]->issueConnect();
}
for(size_t i=0; i<numChannel; ++i)
{
Status status = easyGet[i]->waitConnect();
if(!status.isOK()) {
message = "connect status " + status.getMessage();
allOK = false;
break;
}
}
if(!allOK) throw std::runtime_error(message);
}
void EasyMultiDouble::createPut()
{
EasyChannelArrayPtr easyChannelArray = easyMultiChannel->getEasyChannelArray().lock();
if(!easyChannelArray) throw std::runtime_error("easyChannelArray is gone");
shared_vector<const EasyChannelPtr> easyChannels = *easyChannelArray;
size_t numChannel = easyChannels.size();
easyPut = std::vector<EasyPutPtr>(numChannel,EasyPutPtr());
bool allOK = true;
string message;
for(size_t i=0; i<numChannel; ++i)
{
easyPut[i] = easyChannels[i]->createPut("value");
easyPut[i]->issueConnect();
}
for(size_t i=0; i<numChannel; ++i)
{
Status status = easyPut[i]->waitConnect();
if(!status.isOK()) {
message = "connect status " + status.getMessage();
allOK = false;
break;
}
}
if(!allOK) throw std::runtime_error(message);
}
epics::pvData::shared_vector<double> EasyMultiDouble::get()
{
if(easyGet.empty()) createGet();
shared_vector<const string> channelNames = easyMultiChannel->getChannelNames()->view();
size_t numChannel = channelNames.size();
epics::pvData::shared_vector<double> data(channelNames.size());
for(size_t i=0; i<numChannel; ++i)
{
easyGet[i]->issueGet();
}
for(size_t i=0; i<numChannel; ++i)
{
Status status = easyGet[i]->waitGet();
if(!status.isOK()) {
string message = channelNames[i] + " " + status.getMessage();
throw std::runtime_error(message);
}
data[i] = easyGet[i]->getData()->getDouble();
}
return data;
}
void EasyMultiDouble::put(shared_vector<double> const &value)
{
if(easyPut.empty()) createPut();
shared_vector<const string> channelNames = easyMultiChannel->getChannelNames()->view();
size_t numChannel = channelNames.size();
for(size_t i=0; i<numChannel; ++i)
{
easyPut[i]->getData()->putDouble(value[i]);
easyPut[i]->issuePut();
}
for(size_t i=0; i<numChannel; ++i)
{
Status status = easyPut[i]->waitPut();
if(!status.isOK()) {
string message = channelNames[i] + " " + status.getMessage();
throw std::runtime_error(message);
}
}
}
}}

199
src/easyPVA.cpp
View File

@@ -1,199 +0,0 @@
/* easyPVA.cpp */
/**
* Copyright - See the COPYRIGHT that is included with this distribution.
* EPICS pvData is distributed subject to a Software License Agreement found
* in file LICENSE that is included with this distribution.
*/
/**
* @author mrk
* @date 2015.02
*/
#define epicsExportSharedSymbols
#include <map>
#include <pv/easyPVA.h>
#include <pv/createRequest.h>
#include <pv/clientFactory.h>
#include <pv/caProvider.h>
using std::tr1::static_pointer_cast;
using namespace epics::pvData;
using namespace epics::pvAccess;
using namespace epics::pvAccess::ca;
using namespace std;
namespace epics { namespace easyPVA {
static FieldCreatePtr fieldCreate = getFieldCreate();
static const string easyPVAName = "easyPVA";
static const string defaultProvider = "pva";
static UnionConstPtr variantUnion = fieldCreate->createVariantUnion();
namespace easyPVAPvt {
static size_t numberEasyPVA = 0;
static bool firstTime = true;
static Mutex mutex;
class StartStopClientFactory {
public:
static void EasyPVABeingConstructed()
{
bool saveFirst = false;
{
Lock xx(mutex);
++numberEasyPVA;
saveFirst = firstTime;
firstTime = false;
}
if(saveFirst) {
ClientFactory::start();
CAClientFactory::start();
}
}
static void EasyPVABeingDestroyed() {
size_t numLeft = 0;
{
Lock xx(mutex);
--numberEasyPVA;
numLeft = numberEasyPVA;
}
if(numLeft<=0) {
ClientFactory::stop();
CAClientFactory::stop();
}
}
};
} // namespace easyPVAPvt
class EasyChannelCache
{
public:
EasyChannelCache(){}
~EasyChannelCache(){
destroy();
}
void destroy() {
easyChannelMap.clear();
}
EasyChannelPtr getChannel(string const & channelName);
void addChannel(EasyChannelPtr const & easyChannel);
void removeChannel(string const & channelName);
private:
map<string,EasyChannelPtr> easyChannelMap;
};
EasyChannelPtr EasyChannelCache::getChannel(string const & channelName)
{
map<string,EasyChannelPtr>::iterator iter = easyChannelMap.find(channelName);
if(iter!=easyChannelMap.end()) return iter->second;
return EasyChannelPtr();
}
void EasyChannelCache::addChannel(EasyChannelPtr const & easyChannel)
{
easyChannelMap.insert(std::pair<string,EasyChannelPtr>(
easyChannel->getChannelName(),easyChannel));
}
void EasyChannelCache::removeChannel(string const & channelName)
{
map<string,EasyChannelPtr>::iterator iter = easyChannelMap.find(channelName);
if(iter!=easyChannelMap.end()) easyChannelMap.erase(iter);
}
using namespace epics::easyPVA::easyPVAPvt;
EasyPVAPtr EasyPVA::create()
{
EasyPVAPtr xx(new EasyPVA());
StartStopClientFactory::EasyPVABeingConstructed();
return xx;
}
PVStructurePtr EasyPVA::createRequest(string const &request)
{
CreateRequest::shared_pointer createRequest = CreateRequest::create();
PVStructurePtr pvRequest = createRequest->createRequest(request);
if(!pvRequest) {
throw std::invalid_argument("invalid pvRequest: " + createRequest->getMessage());
}
return pvRequest;
}
EasyPVA::EasyPVA()
: easyChannelCache(new EasyChannelCache()),
isDestroyed(false)
{
}
EasyPVA::~EasyPVA() {
destroy();
}
void EasyPVA::destroy()
{
{
Lock xx(mutex);
if(isDestroyed) return;
isDestroyed = true;
}
easyChannelCache.reset();
channelList.clear();
multiChannelList.clear();
StartStopClientFactory::EasyPVABeingDestroyed();
}
string EasyPVA:: getRequesterName()
{
static string name("easyPVA");
return name;
}
void EasyPVA::message(
string const & message,
MessageType messageType)
{
cout << getMessageTypeName(messageType) << " " << message << endl;
}
EasyChannelPtr EasyPVA::channel(
std::string const & channelName,
std::string const & providerName,
double timeOut)
{
EasyChannelPtr easyChannel = easyChannelCache->getChannel(channelName);
if(easyChannel) return easyChannel;
easyChannel = createChannel(channelName,providerName);
easyChannel->connect(timeOut);
easyChannelCache->addChannel(easyChannel);
return easyChannel;
}
EasyChannelPtr EasyPVA::createChannel(string const & channelName)
{
return EasyChannel::create(getPtrSelf(),channelName);
}
EasyChannelPtr EasyPVA::createChannel(string const & channelName, string const & providerName)
{
return EasyChannel::create(getPtrSelf(),channelName,providerName);
}
EasyMultiChannelPtr EasyPVA::createMultiChannel(
epics::pvData::PVStringArrayPtr const & channelNames)
{
return createMultiChannel(channelNames,"pva");
}
EasyMultiChannelPtr EasyPVA::createMultiChannel(
epics::pvData::PVStringArrayPtr const & channelNames,
std::string const & providerName)
{
return EasyMultiChannel::create(getPtrSelf(),channelNames,providerName);
}
}}

199
src/pvaClient.cpp Normal file
View File

@@ -0,0 +1,199 @@
/* pvaClient.cpp */
/**
* Copyright - See the COPYRIGHT that is included with this distribution.
* EPICS pvData is distributed subject to a Software License Agreement found
* in file LICENSE that is included with this distribution.
*/
/**
* @author mrk
* @date 2015.02
*/
#define epicsExportSharedSymbols
#include <map>
#include <pv/pvaClient.h>
#include <pv/createRequest.h>
#include <pv/clientFactory.h>
#include <pv/caProvider.h>
using std::tr1::static_pointer_cast;
using namespace epics::pvData;
using namespace epics::pvAccess;
using namespace epics::pvAccess::ca;
using namespace std;
namespace epics { namespace pvaClient {
static FieldCreatePtr fieldCreate = getFieldCreate();
static const string pvaClientName = "pvaClient";
static const string defaultProvider = "pva";
static UnionConstPtr variantUnion = fieldCreate->createVariantUnion();
namespace pvaClientPvt {
static size_t numberPvaClient = 0;
static bool firstTime = true;
static Mutex mutex;
class StartStopClientFactory {
public:
static void PvaClientBeingConstructed()
{
bool saveFirst = false;
{
Lock xx(mutex);
++numberPvaClient;
saveFirst = firstTime;
firstTime = false;
}
if(saveFirst) {
ClientFactory::start();
CAClientFactory::start();
}
}
static void PvaClientBeingDestroyed() {
size_t numLeft = 0;
{
Lock xx(mutex);
--numberPvaClient;
numLeft = numberPvaClient;
}
if(numLeft<=0) {
ClientFactory::stop();
CAClientFactory::stop();
}
}
};
} // namespace pvaClientPvt
class PvaClientChannelCache
{
public:
PvaClientChannelCache(){}
~PvaClientChannelCache(){
destroy();
}
void destroy() {
pvaClientChannelMap.clear();
}
PvaClientChannelPtr getChannel(string const & channelName);
void addChannel(PvaClientChannelPtr const & pvaClientChannel);
void removeChannel(string const & channelName);
private:
map<string,PvaClientChannelPtr> pvaClientChannelMap;
};
PvaClientChannelPtr PvaClientChannelCache::getChannel(string const & channelName)
{
map<string,PvaClientChannelPtr>::iterator iter = pvaClientChannelMap.find(channelName);
if(iter!=pvaClientChannelMap.end()) return iter->second;
return PvaClientChannelPtr();
}
void PvaClientChannelCache::addChannel(PvaClientChannelPtr const & pvaClientChannel)
{
pvaClientChannelMap.insert(std::pair<string,PvaClientChannelPtr>(
pvaClientChannel->getChannelName(),pvaClientChannel));
}
void PvaClientChannelCache::removeChannel(string const & channelName)
{
map<string,PvaClientChannelPtr>::iterator iter = pvaClientChannelMap.find(channelName);
if(iter!=pvaClientChannelMap.end()) pvaClientChannelMap.erase(iter);
}
using namespace epics::pvaClient::pvaClientPvt;
PvaClientPtr PvaClient::create()
{
PvaClientPtr xx(new PvaClient());
StartStopClientFactory::PvaClientBeingConstructed();
return xx;
}
PVStructurePtr PvaClient::createRequest(string const &request)
{
CreateRequest::shared_pointer createRequest = CreateRequest::create();
PVStructurePtr pvRequest = createRequest->createRequest(request);
if(!pvRequest) {
throw std::invalid_argument("invalid pvRequest: " + createRequest->getMessage());
}
return pvRequest;
}
PvaClient::PvaClient()
: pvaClientChannelCache(new PvaClientChannelCache()),
isDestroyed(false)
{
}
PvaClient::~PvaClient() {
destroy();
}
void PvaClient::destroy()
{
{
Lock xx(mutex);
if(isDestroyed) return;
isDestroyed = true;
}
pvaClientChannelCache.reset();
channelList.clear();
multiChannelList.clear();
StartStopClientFactory::PvaClientBeingDestroyed();
}
string PvaClient:: getRequesterName()
{
static string name("pvaClient");
return name;
}
void PvaClient::message(
string const & message,
MessageType messageType)
{
cout << getMessageTypeName(messageType) << " " << message << endl;
}
PvaClientChannelPtr PvaClient::channel(
std::string const & channelName,
std::string const & providerName,
double timeOut)
{
PvaClientChannelPtr pvaClientChannel = pvaClientChannelCache->getChannel(channelName);
if(pvaClientChannel) return pvaClientChannel;
pvaClientChannel = createChannel(channelName,providerName);
pvaClientChannel->connect(timeOut);
pvaClientChannelCache->addChannel(pvaClientChannel);
return pvaClientChannel;
}
PvaClientChannelPtr PvaClient::createChannel(string const & channelName)
{
return PvaClientChannel::create(getPtrSelf(),channelName);
}
PvaClientChannelPtr PvaClient::createChannel(string const & channelName, string const & providerName)
{
return PvaClientChannel::create(getPtrSelf(),channelName,providerName);
}
PvaClientMultiChannelPtr PvaClient::createMultiChannel(
epics::pvData::PVStringArrayPtr const & channelNames)
{
return createMultiChannel(channelNames,"pvaClient");
}
PvaClientMultiChannelPtr PvaClient::createMultiChannel(
epics::pvData::PVStringArrayPtr const & channelNames,
std::string const & providerName)
{
return PvaClientMultiChannel::create(getPtrSelf(),channelNames,providerName);
}
}}

570
src/easyPVA.h → src/pvaClient.h
View File

File diff suppressed because it is too large Load Diff

495
src/pvaClientChannel.cpp Normal file
View File

@@ -0,0 +1,495 @@
/* pvaClientChannel.cpp */
/**
* Copyright - See the COPYRIGHT that is included with this distribution.
* EPICS pvData is distributed subject to a Software License Agreement found
* in file LICENSE that is included with this distribution.
*/
/**
* @author mrk
* @date 2015.02
*/
#define epicsExportSharedSymbols
#include <map>
#include <sstream>
#include <pv/event.h>
#include <pv/lock.h>
#include <pv/pvaClient.h>
#include <pv/createRequest.h>
using std::tr1::static_pointer_cast;
using namespace epics::pvData;
using namespace epics::pvAccess;
using namespace std;
namespace epics { namespace pvaClient {
class PvaClientGetCache
{
public:
PvaClientGetCache(){}
~PvaClientGetCache();
void destroy() {
pvaClientGetMap.clear();
}
PvaClientGetPtr getGet(string const & request);
void addGet(string const & request,PvaClientGetPtr const & pvaClientGet);
private:
map<string,PvaClientGetPtr> pvaClientGetMap;
};
PvaClientGetCache::~PvaClientGetCache()
{
destroy();
}
PvaClientGetPtr PvaClientGetCache::getGet(string const & request)
{
map<string,PvaClientGetPtr>::iterator iter = pvaClientGetMap.find(request);
if(iter!=pvaClientGetMap.end()) return iter->second;
return PvaClientGetPtr();
}
void PvaClientGetCache::addGet(string const & request,PvaClientGetPtr const & pvaClientGet)
{
pvaClientGetMap.insert(std::pair<string,PvaClientGetPtr>(
request,pvaClientGet));
}
class PvaClientPutCache
{
public:
PvaClientPutCache(){}
~PvaClientPutCache();
void destroy() {
pvaClientPutMap.clear();
}
PvaClientPutPtr getPut(string const & request);
void addPut(string const & request,PvaClientPutPtr const & pvaClientPut);
private:
map<string,PvaClientPutPtr> pvaClientPutMap;
};
PvaClientPutCache::~PvaClientPutCache()
{
destroy();
}
PvaClientPutPtr PvaClientPutCache::getPut(string const & request)
{
map<string,PvaClientPutPtr>::iterator iter = pvaClientPutMap.find(request);
if(iter!=pvaClientPutMap.end()) return iter->second;
return PvaClientPutPtr();
}
void PvaClientPutCache::addPut(string const & request,PvaClientPutPtr const & pvaClientPut)
{
pvaClientPutMap.insert(std::pair<string,PvaClientPutPtr>(
request,pvaClientPut));
}
class ChannelRequesterImpl : public ChannelRequester
{
PvaClientChannel *pvaClientChannel;
public:
ChannelRequesterImpl(PvaClientChannel *pvaClientChannel)
: pvaClientChannel(pvaClientChannel) {}
void channelCreated(
const Status& status,
Channel::shared_pointer const & channel)
{ pvaClientChannel->channelCreated(status,channel); }
void channelStateChange(
Channel::shared_pointer const & channel,
Channel::ConnectionState connectionState)
{pvaClientChannel->channelStateChange(channel,connectionState);}
tr1::shared_ptr<Channel> getChannel() {return pvaClientChannel->getChannel();}
string getRequesterName()
{return pvaClientChannel->getRequesterName();}
void message(
string const & message,
MessageType messageType)
{ pvaClientChannel->message(message,messageType); }
void destroy() {pvaClientChannel->destroy();}
};
PvaClientChannel::PvaClientChannel(
PvaClientPtr const &pvaClient,
string const & channelName,
string const & providerName)
: pvaClient(pvaClient),
channelName(channelName),
providerName(providerName),
connectState(connectIdle),
isDestroyed(false),
createRequest(CreateRequest::create()),
pvaClientGetCache(new PvaClientGetCache()),
pvaClientPutCache(new PvaClientPutCache())
{}
PvaClientChannel::~PvaClientChannel()
{
destroy();
}
void PvaClientChannel::channelCreated(const Status& status, Channel::shared_pointer const & channel)
{
if(isDestroyed) throw std::runtime_error("pvaClientChannel was destroyed");
if(status.isOK()) {
this->channel = channel;
return;
}
cout << "PvaClientChannel::channelCreated status " << status.getMessage() << " why??\n";
}
void PvaClientChannel::channelStateChange(
Channel::shared_pointer const & channel,
Channel::ConnectionState connectionState)
{
if(isDestroyed) return;
bool waitingForConnect = false;
if(connectState==connectActive) waitingForConnect = true;
if(connectionState!=Channel::CONNECTED) {
string mess(channelName +
" connection state " + Channel::ConnectionStateNames[connectionState]);
message(mess,errorMessage);
channelConnectStatus = Status(Status::STATUSTYPE_ERROR,mess);
connectState = notConnected;
} else {
connectState = connected;
}
if(waitingForConnect) waitForConnect.signal();
}
string PvaClientChannel::getRequesterName()
{
PvaClientPtr yyy = pvaClient.lock();
if(!yyy) throw std::runtime_error("PvaClient was destroyed");
return yyy->getRequesterName();
}
void PvaClientChannel::message(
string const & message,
MessageType messageType)
{
if(isDestroyed) throw std::runtime_error("pvaClientChannel was destroyed");
PvaClientPtr yyy = pvaClient.lock();
if(!yyy) throw std::runtime_error("PvaClient was destroyed");
yyy->message(message, messageType);
}
void PvaClientChannel::destroy()
{
{
Lock xx(mutex);
if(isDestroyed) return;
isDestroyed = true;
}
if(channel) channel->destroy();
channel.reset();
pvaClientGetCache.reset();
pvaClientPutCache.reset();
}
string PvaClientChannel::getChannelName()
{
if(isDestroyed) throw std::runtime_error("pvaClientChannel was destroyed");
return channelName;
}
Channel::shared_pointer PvaClientChannel::getChannel()
{
if(isDestroyed) throw std::runtime_error("pvaClientChannel was destroyed");
return channel;
}
void PvaClientChannel::connect(double timeout)
{
if(isDestroyed) throw std::runtime_error("pvaClientChannel was destroyed");
issueConnect();
Status status = waitConnect(timeout);
if(status.isOK()) return;
stringstream ss;
ss << "channel " << getChannelName() << " PvaClientChannel::connect " << status.getMessage();
throw std::runtime_error(ss.str());
}
void PvaClientChannel::issueConnect()
{
if(isDestroyed) throw std::runtime_error("pvaClientChannel was destroyed");
if(connectState!=connectIdle) {
throw std::runtime_error("pvaClientChannel already connected");
}
channelRequester = ChannelRequester::shared_pointer(new ChannelRequesterImpl(this));
channelConnectStatus = Status(
Status::STATUSTYPE_ERROR,
getChannelName() + " createChannel failed");
connectState = connectActive;
ChannelProviderRegistry::shared_pointer reg = getChannelProviderRegistry();
ChannelProvider::shared_pointer provider = reg->getProvider(providerName);
if(!provider) {
throw std::runtime_error(getChannelName() + " provider " + providerName + " not registered");
}
channel = provider->createChannel(channelName,channelRequester,ChannelProvider::PRIORITY_DEFAULT);
if(!channel) {
throw std::runtime_error(channelConnectStatus.getMessage());
}
}
Status PvaClientChannel::waitConnect(double timeout)
{
if(isDestroyed) throw std::runtime_error("pvaClientChannel was destroyed");
waitForConnect.wait(timeout);
if(connectState==connected) return Status::Ok;
return Status(Status::STATUSTYPE_ERROR,channelConnectStatus.getMessage());
}
PvaClientFieldPtr PvaClientChannel::createField()
{
return createField("");
}
PvaClientFieldPtr PvaClientChannel::createField(string const & subField)
{
throw std::runtime_error("PvaClientChannel::createField not implemented");
}
PvaClientProcessPtr PvaClientChannel::createProcess()
{
return createProcess("");
}
PvaClientProcessPtr PvaClientChannel::createProcess(string const & request)
{
PVStructurePtr pvRequest = createRequest->createRequest(request);
if(!pvRequest) {
stringstream ss;
ss << "channel " << getChannelName();
ss << " PvaClientChannel::createProcess invalid pvRequest: " + createRequest->getMessage();
throw std::runtime_error(ss.str());
}
return createProcess(pvRequest);
}
PvaClientProcessPtr PvaClientChannel::createProcess(PVStructurePtr const & pvRequest)
{
if(connectState!=connected) connect(5.0);
if(connectState!=connected) throw std::runtime_error("PvaClientChannel::creatProcess not connected");
PvaClientPtr yyy = pvaClient.lock();
if(!yyy) throw std::runtime_error("PvaClient was destroyed");
return PvaClientProcess::create(yyy,getPtrSelf(),channel,pvRequest);
}
PvaClientGetPtr PvaClientChannel::get() {return get("value,alarm,timeStamp");}
PvaClientGetPtr PvaClientChannel::get(string const & request)
{
PvaClientGetPtr pvaClientGet = pvaClientGetCache->getGet(request);
if(pvaClientGet) return pvaClientGet;
pvaClientGet = createGet(request);
pvaClientGet->connect();
pvaClientGetCache->addGet(request,pvaClientGet);
return pvaClientGet;
}
PvaClientGetPtr PvaClientChannel::createGet()
{
return PvaClientChannel::createGet("value,alarm,timeStamp");
}
PvaClientGetPtr PvaClientChannel::createGet(string const & request)
{
PVStructurePtr pvRequest = createRequest->createRequest(request);
if(!pvRequest) {
stringstream ss;
ss << "channel " << getChannelName();
ss << " PvaClientChannel::createGet invalid pvRequest: " + createRequest->getMessage();
throw std::runtime_error(ss.str());
}
return createGet(pvRequest);
}
PvaClientGetPtr PvaClientChannel::createGet(PVStructurePtr const & pvRequest)
{
if(connectState!=connected) connect(5.0);
if(connectState!=connected) throw std::runtime_error("PvaClientChannel::creatGet not connected");
PvaClientPtr yyy = pvaClient.lock();
if(!yyy) throw std::runtime_error("PvaClient was destroyed");
return PvaClientGet::create(yyy,getPtrSelf(),channel,pvRequest);
}
PvaClientPutPtr PvaClientChannel::put() {return put("value");}
PvaClientPutPtr PvaClientChannel::put(string const & request)
{
PvaClientPutPtr pvaClientPut = pvaClientPutCache->getPut(request);
if(pvaClientPut) return pvaClientPut;
pvaClientPut = createPut(request);
pvaClientPut->connect();
pvaClientPut->get();
pvaClientPutCache->addPut(request,pvaClientPut);
return pvaClientPut;
}
PvaClientPutPtr PvaClientChannel::createPut()
{
return createPut("value");
}
PvaClientPutPtr PvaClientChannel::createPut(string const & request)
{
PVStructurePtr pvRequest = createRequest->createRequest(request);
if(!pvRequest) {
stringstream ss;
ss << "channel " << getChannelName();
ss << " PvaClientChannel::createPut invalid pvRequest: " + createRequest->getMessage();
throw std::runtime_error(ss.str());
}
return createPut(pvRequest);
}
PvaClientPutPtr PvaClientChannel::createPut(PVStructurePtr const & pvRequest)
{
if(connectState!=connected) connect(5.0);
if(connectState!=connected) throw std::runtime_error("PvaClientChannel::creatPut not connected");
PvaClientPtr yyy = pvaClient.lock();
if(!yyy) throw std::runtime_error("PvaClient was destroyed");
return PvaClientPut::create(yyy,getPtrSelf(),channel,pvRequest);
}
PvaClientPutGetPtr PvaClientChannel::createPutGet()
{
return createPutGet("putField(argument)getField(result)");
}
PvaClientPutGetPtr PvaClientChannel::createPutGet(string const & request)
{
PVStructurePtr pvRequest = createRequest->createRequest(request);
if(!pvRequest) {
stringstream ss;
ss << "channel " << getChannelName();
ss << " PvaClientChannel::createPutGet invalid pvRequest: " + createRequest->getMessage();
throw std::runtime_error(ss.str());
}
return createPutGet(pvRequest);
}
PvaClientPutGetPtr PvaClientChannel::createPutGet(PVStructurePtr const & pvRequest)
{
if(connectState!=connected) connect(5.0);
if(connectState!=connected) throw std::runtime_error("PvaClientChannel::creatPutGet not connected");
PvaClientPtr yyy = pvaClient.lock();
if(!yyy) throw std::runtime_error("PvaClient was destroyed");
return PvaClientPutGet::create(yyy,getPtrSelf(),channel,pvRequest);
}
PvaClientRPCPtr PvaClientChannel::createRPC()
{
return createRPC("");
}
PvaClientRPCPtr PvaClientChannel::createRPC(string const & request)
{
PVStructurePtr pvRequest = createRequest->createRequest(request);
if(!pvRequest) {
stringstream ss;
ss << "channel " << getChannelName();
ss << " PvaClientChannel::createRPC invalid pvRequest: " + createRequest->getMessage();
throw std::runtime_error(ss.str());
}
return createRPC(pvRequest);
}
PvaClientRPCPtr PvaClientChannel::createRPC(PVStructurePtr const & pvRequest)
{
throw std::runtime_error("PvaClientChannel::createRPC not implemented");
}
PvaClientArrayPtr PvaClientChannel::createArray()
{
return createArray("value");
}
PvaClientArrayPtr PvaClientChannel::createArray(string const & request)
{
PVStructurePtr pvRequest = createRequest->createRequest(request);
if(!pvRequest) {
stringstream ss;
ss << "channel " << getChannelName();
ss << " PvaClientChannel::createArray invalid pvRequest: " + createRequest->getMessage();
throw std::runtime_error(ss.str());
}
return createArray(pvRequest);
}
PvaClientArrayPtr PvaClientChannel::createArray(PVStructurePtr const & pvRequest)
{
throw std::runtime_error("PvaClientChannel::createArray not implemented");
}
PvaClientMonitorPtr PvaClientChannel::monitor() {return monitor("value,alarm,timeStamp");}
PvaClientMonitorPtr PvaClientChannel::monitor(string const & request)
{
PvaClientMonitorPtr pvaClientMonitor = createMonitor(request);
pvaClientMonitor->connect();
pvaClientMonitor->start();
return pvaClientMonitor;
}
PvaClientMonitorPtr PvaClientChannel::monitor(PvaClientMonitorRequesterPtr const & pvaClientMonitorRequester)
{ return monitor("value,alarm,timeStamp",pvaClientMonitorRequester);
}
PvaClientMonitorPtr PvaClientChannel::monitor(string const & request,
PvaClientMonitorRequesterPtr const & pvaClientMonitorRequester)
{
PvaClientMonitorPtr pvaClientMonitor = createMonitor(request);
pvaClientMonitor->connect();
pvaClientMonitor->setRequester(pvaClientMonitorRequester);
pvaClientMonitor->start();
return pvaClientMonitor;
}
PvaClientMonitorPtr PvaClientChannel::createMonitor()
{
return createMonitor("value,alarm,timeStamp");
}
PvaClientMonitorPtr PvaClientChannel::createMonitor(string const & request)
{
PVStructurePtr pvRequest = createRequest->createRequest(request);
if(!pvRequest) {
stringstream ss;
ss << "channel " << getChannelName();
ss << " PvaClientChannel::createMonitor invalid pvRequest: " + createRequest->getMessage();
throw std::runtime_error(ss.str());
}
return createMonitor(pvRequest);
}
PvaClientMonitorPtr PvaClientChannel::createMonitor(PVStructurePtr const & pvRequest)
{
if(connectState!=connected) connect(5.0);
if(connectState!=connected) throw std::runtime_error("PvaClientChannel::createMonitor not connected");
PvaClientPtr yyy = pvaClient.lock();
if(!yyy) throw std::runtime_error("PvaClient was destroyed");
return PvaClientMonitor::create(yyy,getPtrSelf(),channel,pvRequest);
}
PvaClientChannelPtr PvaClientChannel::create(
PvaClientPtr const &pvaClient,
string const & channelName,
string const & providerName)
{
PvaClientChannelPtr channel(new PvaClientChannel(pvaClient,channelName,providerName));
return channel;
}
}}

116
src/easyGet.cpp → src/pvaClientGet.cpp
View File

@@ -1,4 +1,4 @@
/* easyGet.cpp */
/* pvaClientGet.cpp */
/**
* Copyright - See the COPYRIGHT that is included with this distribution.
* EPICS pvData is distributed subject to a Software License Agreement found
@@ -12,46 +12,46 @@
#include <sstream>
#include <pv/event.h>
#include <pv/easyPVA.h>
#include <pv/pvaClient.h>
using std::tr1::static_pointer_cast;
using namespace epics::pvData;
using namespace epics::pvAccess;
using namespace std;
namespace epics { namespace easyPVA {
namespace epics { namespace pvaClient {
class ChannelGetRequesterImpl : public ChannelGetRequester
{
EasyGet * easyGet;
PvaClientGet * pvaClientGet;
public:
ChannelGetRequesterImpl(EasyGet * easyGet)
: easyGet(easyGet) {}
ChannelGetRequesterImpl(PvaClientGet * pvaClientGet)
: pvaClientGet(pvaClientGet) {}
string getRequesterName()
{return easyGet->getRequesterName();}
{return pvaClientGet->getRequesterName();}
void message(string const & message,MessageType messageType)
{easyGet->message(message,messageType);}
{pvaClientGet->message(message,messageType);}
void channelGetConnect(
const Status& status,
ChannelGet::shared_pointer const & channelGet,
StructureConstPtr const & structure)
{easyGet->channelGetConnect(status,channelGet,structure);}
{pvaClientGet->channelGetConnect(status,channelGet,structure);}
void getDone(
const Status& status,
ChannelGet::shared_pointer const & channelGet,
PVStructurePtr const & pvStructure,
BitSetPtr const & bitSet)
{easyGet->getDone(status,channelGet,pvStructure,bitSet);}
{pvaClientGet->getDone(status,channelGet,pvStructure,bitSet);}
};
EasyGet::EasyGet(
EasyPVAPtr const &pva,
EasyChannelPtr const & easyChannel,
PvaClientGet::PvaClientGet(
PvaClientPtr const &pvaClient,
PvaClientChannelPtr const & pvaClientChannel,
Channel::shared_pointer const & channel,
PVStructurePtr const &pvRequest)
: easyPVA(pva),
easyChannel(easyChannel),
: pvaClient(pvaClient),
pvaClientChannel(pvaClientChannel),
channel(channel),
pvRequest(pvRequest),
isDestroyed(false),
@@ -60,67 +60,67 @@ EasyGet::EasyGet(
{
}
EasyGet::~EasyGet()
PvaClientGet::~PvaClientGet()
{
destroy();
}
void EasyGet::checkGetState()
void PvaClientGet::checkGetState()
{
if(isDestroyed) throw std::runtime_error("easyGet was destroyed");
if(isDestroyed) throw std::runtime_error("pvaClientGet was destroyed");
if(connectState==connectIdle) connect();
if(getState==getIdle) get();
}
// from ChannelGetRequester
string EasyGet::getRequesterName()
string PvaClientGet::getRequesterName()
{
EasyPVAPtr yyy = easyPVA.lock();
if(!yyy) throw std::runtime_error("easyPVA was destroyed");
PvaClientPtr yyy = pvaClient.lock();
if(!yyy) throw std::runtime_error("pvaClient was destroyed");
return yyy->getRequesterName();
}
void EasyGet::message(string const & message,MessageType messageType)
void PvaClientGet::message(string const & message,MessageType messageType)
{
if(isDestroyed) throw std::runtime_error("easyGet was destroyed");
EasyPVAPtr yyy = easyPVA.lock();
if(!yyy) throw std::runtime_error("easyPVA was destroyed");
if(isDestroyed) throw std::runtime_error("pvaClientGet was destroyed");
PvaClientPtr yyy = pvaClient.lock();
if(!yyy) throw std::runtime_error("pvaClient was destroyed");
yyy->message(message, messageType);
}
void EasyGet::channelGetConnect(
void PvaClientGet::channelGetConnect(
const Status& status,
ChannelGet::shared_pointer const & channelGet,
StructureConstPtr const & structure)
{
if(isDestroyed) throw std::runtime_error("easyGet was destroyed");
if(isDestroyed) throw std::runtime_error("pvaClientGet was destroyed");
channelGetConnectStatus = status;
this->channelGet = channelGet;
if(status.isOK()) {
easyData = EasyGetData::create(structure);
easyData->setMessagePrefix(channel->getChannelName());
pvaClientData = PvaClientGetData::create(structure);
pvaClientData->setMessagePrefix(channel->getChannelName());
}
waitForConnect.signal();
}
void EasyGet::getDone(
void PvaClientGet::getDone(
const Status& status,
ChannelGet::shared_pointer const & channelGet,
PVStructurePtr const & pvStructure,
BitSetPtr const & bitSet)
{
if(isDestroyed) throw std::runtime_error("easyGet was destroyed");
if(isDestroyed) throw std::runtime_error("pvaClientGet was destroyed");
channelGetStatus = status;
if(status.isOK()) {
easyData->setData(pvStructure,bitSet);
pvaClientData->setData(pvStructure,bitSet);
}
waitForGet.signal();
}
// from EasyGet
void EasyGet::destroy()
// from PvaClientGet
void PvaClientGet::destroy()
{
{
Lock xx(mutex);
@@ -131,23 +131,23 @@ void EasyGet::destroy()
channelGet.reset();
}
void EasyGet::connect()
void PvaClientGet::connect()
{
if(isDestroyed) throw std::runtime_error("easyGet was destroyed");
if(isDestroyed) throw std::runtime_error("pvaClientGet was destroyed");
issueConnect();
Status status = waitConnect();
if(status.isOK()) return;
stringstream ss;
ss << "channel " << channel->getChannelName() << " EasyGet::connect " << status.getMessage();
ss << "channel " << channel->getChannelName() << " PvaClientGet::connect " << status.getMessage();
throw std::runtime_error(ss.str());
}
void EasyGet::issueConnect()
void PvaClientGet::issueConnect()
{
if(isDestroyed) throw std::runtime_error("easyGet was destroyed");
if(isDestroyed) throw std::runtime_error("pvaClientGet was destroyed");
if(connectState!=connectIdle) {
stringstream ss;
ss << "channel " << channel->getChannelName() << " easyGet already connected ";
ss << "channel " << channel->getChannelName() << " pvaClientGet already connected ";
throw std::runtime_error(ss.str());
}
getRequester = ChannelGetRequester::shared_pointer(new ChannelGetRequesterImpl(this));
@@ -155,12 +155,12 @@ void EasyGet::issueConnect()
channelGet = channel->createChannelGet(getRequester,pvRequest);
}
Status EasyGet::waitConnect()
Status PvaClientGet::waitConnect()
{
if(isDestroyed) throw std::runtime_error("easyGet was destroyed");
if(isDestroyed) throw std::runtime_error("pvaClientGet was destroyed");
if(connectState!=connectActive) {
stringstream ss;
ss << "channel " << channel->getChannelName() << " easyGet illegal connect state ";
ss << "channel " << channel->getChannelName() << " pvaClientGet illegal connect state ";
throw std::runtime_error(ss.str());
}
waitForConnect.wait();
@@ -172,36 +172,36 @@ Status EasyGet::waitConnect()
return Status(Status::STATUSTYPE_ERROR,channelGetConnectStatus.getMessage());
}
void EasyGet::get()
void PvaClientGet::get()
{
if(isDestroyed) throw std::runtime_error("easyGet was destroyed");
if(isDestroyed) throw std::runtime_error("pvaClientGet was destroyed");
issueGet();
Status status = waitGet();
if(status.isOK()) return;
stringstream ss;
ss << "channel " << channel->getChannelName() << " EasyGet::get " << status.getMessage();
ss << "channel " << channel->getChannelName() << " PvaClientGet::get " << status.getMessage();
throw std::runtime_error(ss.str());
}
void EasyGet::issueGet()
void PvaClientGet::issueGet()
{
if(isDestroyed) throw std::runtime_error("easyGet was destroyed");
if(isDestroyed) throw std::runtime_error("pvaClientGet was destroyed");
if(connectState==connectIdle) connect();
if(getState!=getIdle) {
stringstream ss;
ss << "channel " << channel->getChannelName() << " EasyGet::issueGet get aleady active ";
ss << "channel " << channel->getChannelName() << " PvaClientGet::issueGet get aleady active ";
throw std::runtime_error(ss.str());
}
getState = getActive;
channelGet->get();
}
Status EasyGet::waitGet()
Status PvaClientGet::waitGet()
{
if(isDestroyed) throw std::runtime_error("easyGet was destroyed");
if(isDestroyed) throw std::runtime_error("pvaClientGet was destroyed");
if(getState!=getActive){
stringstream ss;
ss << "channel " << channel->getChannelName() << " EasyGet::waitGet llegal get state";
ss << "channel " << channel->getChannelName() << " PvaClientGet::waitGet llegal get state";
throw std::runtime_error(ss.str());
}
waitForGet.wait();
@@ -211,19 +211,19 @@ Status EasyGet::waitGet()
}
return Status(Status::STATUSTYPE_ERROR,channelGetStatus.getMessage());
}
EasyGetDataPtr EasyGet::getData()
PvaClientGetDataPtr PvaClientGet::getData()
{
checkGetState();
return easyData;
return pvaClientData;
}
EasyGetPtr EasyGet::create(
EasyPVAPtr const &pva,
EasyChannelPtr const & easyChannel,
PvaClientGetPtr PvaClientGet::create(
PvaClientPtr const &pvaClient,
PvaClientChannelPtr const & pvaClientChannel,
Channel::shared_pointer const & channel,
PVStructurePtr const &pvRequest)
{
EasyGetPtr epv(new EasyGet(pva,easyChannel,channel,pvRequest));
PvaClientGetPtr epv(new PvaClientGet(pvaClient,pvaClientChannel,channel,pvRequest));
return epv;
}

84
src/easyGetData.cpp → src/pvaClientGetData.cpp
View File

@@ -1,4 +1,4 @@
/* easyGetData.cpp */
/* pvaClientGetData.cpp */
/**
* Copyright - See the COPYRIGHT that is included with this distribution.
* EPICS pvData is distributed subject to a Software License Agreement found
@@ -13,7 +13,7 @@
#include <typeinfo>
#include <sstream>
#include <pv/easyPVA.h>
#include <pv/pvaClient.h>
#include <pv/createRequest.h>
#include <pv/convert.h>
@@ -23,7 +23,7 @@ using namespace epics::pvData;
using namespace epics::pvAccess;
using namespace std;
namespace epics { namespace easyPVA {
namespace epics { namespace pvaClient {
typedef std::tr1::shared_ptr<PVArray> PVArrayPtr;
@@ -36,44 +36,46 @@ static string noArray("value is not an array");
static string noScalarArray("value is not a scalarArray");
static string notDoubleArray("value is not a doubleArray");
static string notStringArray("value is not a stringArray");
static string noAlarm("no alarm");
static string noTimeStamp("no timeStamp");
EasyGetDataPtr EasyGetData::create(StructureConstPtr const & structure)
PvaClientGetDataPtr PvaClientGetData::create(StructureConstPtr const & structure)
{
EasyGetDataPtr epv(new EasyGetData(structure));
PvaClientGetDataPtr epv(new PvaClientGetData(structure));
return epv;
}
EasyGetData::EasyGetData(StructureConstPtr const & structure)
PvaClientGetData::PvaClientGetData(StructureConstPtr const & structure)
: structure(structure)
{}
void EasyGetData::checkValue()
void PvaClientGetData::checkValue()
{
if(pvValue) return;
throw std::runtime_error(messagePrefix + noValue);
}
void EasyGetData::setMessagePrefix(std::string const & value)
void PvaClientGetData::setMessagePrefix(std::string const & value)
{
messagePrefix = value + " ";
}
StructureConstPtr EasyGetData::getStructure()
StructureConstPtr PvaClientGetData::getStructure()
{return structure;}
PVStructurePtr EasyGetData::getPVStructure()
PVStructurePtr PvaClientGetData::getPVStructure()
{
if(pvStructure) return pvStructure;
throw std::runtime_error(messagePrefix + noStructure);
}
BitSetPtr EasyGetData::getBitSet()
BitSetPtr PvaClientGetData::getBitSet()
{
if(bitSet)return bitSet;
throw std::runtime_error(messagePrefix + noStructure);
}
std::ostream & EasyGetData::showChanged(std::ostream & out)
std::ostream & PvaClientGetData::showChanged(std::ostream & out)
{
if(!bitSet) throw std::runtime_error(messagePrefix + noStructure);
size_t nextSet = bitSet->nextSetBit(0);
@@ -91,7 +93,7 @@ std::ostream & EasyGetData::showChanged(std::ostream & out)
return out;
}
void EasyGetData::setData(
void PvaClientGetData::setData(
PVStructurePtr const & pvStructureFrom,
BitSetPtr const & bitSetFrom)
{
@@ -100,33 +102,33 @@ void EasyGetData::setData(
pvValue = pvStructure->getSubField("value");
}
bool EasyGetData::hasValue()
bool PvaClientGetData::hasValue()
{
if(!pvValue) return false;
return true;
}
bool EasyGetData::isValueScalar()
bool PvaClientGetData::isValueScalar()
{
if(!pvValue) return false;
if(pvValue->getField()->getType()==scalar) return true;
return false;
}
bool EasyGetData::isValueScalarArray()
bool PvaClientGetData::isValueScalarArray()
{
if(!pvValue) return false;
if(pvValue->getField()->getType()==scalarArray) return true;
return false;
}
PVFieldPtr EasyGetData::getValue()
PVFieldPtr PvaClientGetData::getValue()
{
checkValue();
return pvValue;
}
PVScalarPtr EasyGetData::getScalarValue()
PVScalarPtr PvaClientGetData::getScalarValue()
{
checkValue();
PVScalarPtr pv = pvStructure->getSubField<PVScalar>("value");
@@ -136,7 +138,7 @@ PVScalarPtr EasyGetData::getScalarValue()
return pv;
}
PVArrayPtr EasyGetData::getArrayValue()
PVArrayPtr PvaClientGetData::getArrayValue()
{
checkValue();
PVArrayPtr pv = pvStructure->getSubField<PVArray>("value");
@@ -146,7 +148,7 @@ PVArrayPtr EasyGetData::getArrayValue()
return pv;
}
PVScalarArrayPtr EasyGetData::getScalarArrayValue()
PVScalarArrayPtr PvaClientGetData::getScalarArrayValue()
{
checkValue();
PVScalarArrayPtr pv = pvStructure->getSubField<PVScalarArray>("value");
@@ -156,7 +158,7 @@ PVScalarArrayPtr EasyGetData::getScalarArrayValue()
return pv;
}
double EasyGetData::getDouble()
double PvaClientGetData::getDouble()
{
PVScalarPtr pvScalar = getScalarValue();
ScalarType scalarType = pvScalar->getScalar()->getScalarType();
@@ -170,13 +172,13 @@ double EasyGetData::getDouble()
return convert->toDouble(pvScalar);
}
string EasyGetData::getString()
string PvaClientGetData::getString()
{
PVScalarPtr pvScalar = getScalarValue();
return convert->toString(pvScalar);
}
shared_vector<const double> EasyGetData::getDoubleArray()
shared_vector<const double> PvaClientGetData::getDoubleArray()
{
checkValue();
PVDoubleArrayPtr pv = pvStructure->getSubField<PVDoubleArray>("value");
@@ -186,7 +188,7 @@ shared_vector<const double> EasyGetData::getDoubleArray()
return pv->view();
}
shared_vector<const string> EasyGetData::getStringArray()
shared_vector<const string> PvaClientGetData::getStringArray()
{
checkValue();
PVStringArrayPtr pv = pvStructure->getSubField<PVStringArray>("value");
@@ -194,7 +196,41 @@ shared_vector<const string> EasyGetData::getStringArray()
throw std::runtime_error(messagePrefix + notStringArray);
}
return pv->view();
}
Alarm PvaClientGetData::getAlarm()
{
if(!pvStructure) {
throw std::runtime_error(messagePrefix + noAlarm);
}
PVStructurePtr pvs = pvStructure->getSubField<PVStructure>("alarm");
if(!pvs) throw std::runtime_error(messagePrefix + noAlarm);
pvAlarm.attach(pvs);
if(pvAlarm.isAttached()) {
Alarm alarm;
pvAlarm.get(alarm);
pvAlarm.detach();
return alarm;
}
throw std::runtime_error(messagePrefix + noAlarm);
}
TimeStamp PvaClientGetData::getTimeStamp()
{
if(!pvStructure) {
throw std::runtime_error(messagePrefix + noTimeStamp);
}
PVStructurePtr pvs = pvStructure->getSubField<PVStructure>("timeStamp");
if(!pvs) throw std::runtime_error(messagePrefix + noTimeStamp);
pvTimeStamp.attach(pvs);
if(pvTimeStamp.isAttached()) {
TimeStamp timeStamp;
pvTimeStamp.get(timeStamp);
pvTimeStamp.detach();
return timeStamp;
}
throw std::runtime_error(messagePrefix + noTimeStamp);
}
}}

250
src/pvaClientMonitor.cpp Normal file
View File

@@ -0,0 +1,250 @@
/* pvaClientMonitor.cpp */
/**
* Copyright - See the COPYRIGHT that is included with this distribution.
* EPICS pvData is distributed subject to a Software License Agreement found
* in file LICENSE that is included with this distribution.
*/
/**
* @author mrk
* @date 2015.03
*/
#define epicsExportSharedSymbols
#include <sstream>
#include <pv/event.h>
#include <pv/pvaClient.h>
#include <pv/bitSetUtil.h>
using std::tr1::static_pointer_cast;
using namespace epics::pvData;
using namespace epics::pvAccess;
using namespace std;
namespace epics { namespace pvaClient {
class ChannelMonitorRequester : public MonitorRequester
{
PvaClientMonitor * pvaClientMonitor;
public:
ChannelMonitorRequester(PvaClientMonitor * pvaClientMonitor)
: pvaClientMonitor(pvaClientMonitor) {}
string getRequesterName()
{return pvaClientMonitor->getRequesterName();}
void message(string const & message,MessageType messageType)
{pvaClientMonitor->message(message,messageType);}
void monitorConnect(
const Status& status,
Monitor::shared_pointer const & monitor,
StructureConstPtr const & structure)
{pvaClientMonitor->monitorConnect(status,monitor,structure);}
void monitorEvent(MonitorPtr const & monitor)
{
pvaClientMonitor->monitorEvent(monitor);
}
void unlisten(MonitorPtr const & monitor)
{pvaClientMonitor->unlisten();}
};
PvaClientMonitor::PvaClientMonitor(
PvaClientPtr const &pvaClient,
PvaClientChannelPtr const & pvaClientChannel,
Channel::shared_pointer const & channel,
PVStructurePtr const &pvRequest)
: pvaClient(pvaClient),
pvaClientChannel(pvaClientChannel),
channel(channel),
pvRequest(pvRequest),
isDestroyed(false),
connectState(connectIdle),
userPoll(false),
userWait(false)
{
}
PvaClientMonitor::~PvaClientMonitor()
{
destroy();
}
void PvaClientMonitor::checkMonitorState()
{
if(isDestroyed) throw std::runtime_error("pvaClientMonitor was destroyed");
if(connectState==connectIdle) connect();
if(connectState==connected) start();
}
// from MonitorRequester
string PvaClientMonitor::getRequesterName()
{
PvaClientPtr yyy = pvaClient.lock();
if(!yyy) throw std::runtime_error("pvaClient was destroyed");
return yyy->getRequesterName();
}
void PvaClientMonitor::message(string const & message,MessageType messageType)
{
if(isDestroyed) throw std::runtime_error("pvaClientMonitor was destroyed");
PvaClientPtr yyy = pvaClient.lock();
if(!yyy) throw std::runtime_error("pvaClient was destroyed");
yyy->message(message, messageType);
}
void PvaClientMonitor::monitorConnect(
const Status& status,
Monitor::shared_pointer const & monitor,
StructureConstPtr const & structure)
{
if(isDestroyed) throw std::runtime_error("pvaClientMonitor was destroyed");
connectStatus = status;
this->monitor = monitor;
if(status.isOK()) {
pvaClientData = PvaClientMonitorData::create(structure);
pvaClientData->setMessagePrefix(channel->getChannelName());
}
waitForConnect.signal();
}
void PvaClientMonitor::monitorEvent(MonitorPtr const & monitor)
{
PvaClientMonitorRequesterPtr req = pvaClientMonitorRequester.lock();
if(req) req->event(getPtrSelf());
if(userWait) waitForEvent.signal();
}
void PvaClientMonitor::unlisten()
{
destroy();
}
// from PvaClientMonitor
void PvaClientMonitor::destroy()
{
{
Lock xx(mutex);
if(isDestroyed) return;
isDestroyed = true;
}
if(monitor) monitor->destroy();
monitor.reset();
}
void PvaClientMonitor::connect()
{
if(isDestroyed) throw std::runtime_error("pvaClientMonitor was destroyed");
issueConnect();
Status status = waitConnect();
if(status.isOK()) return;
stringstream ss;
ss << "channel " << channel->getChannelName() << " PvaClientMonitor::connect " << status.getMessage();
throw std::runtime_error(ss.str());
}
void PvaClientMonitor::issueConnect()
{
if(isDestroyed) throw std::runtime_error("pvaClientMonitor was destroyed");
if(connectState!=connectIdle) {
stringstream ss;
ss << "channel " << channel->getChannelName() << " pvaClientMonitor already connected ";
throw std::runtime_error(ss.str());
}
monitorRequester = ChannelMonitorRequester::shared_pointer(new ChannelMonitorRequester(this));
connectState = connectActive;
monitor = channel->createMonitor(monitorRequester,pvRequest);
}
Status PvaClientMonitor::waitConnect()
{
if(isDestroyed) throw std::runtime_error("pvaClientMonitor was destroyed");
if(connectState!=connectActive) {
stringstream ss;
ss << "channel " << channel->getChannelName() << " pvaClientMonitor illegal connect state ";
throw std::runtime_error(ss.str());
}
waitForConnect.wait();
if(connectStatus.isOK()){
connectState = connected;
return Status::Ok;
}
connectState = connectIdle;
return Status(Status::STATUSTYPE_ERROR,connectStatus.getMessage());
}
void PvaClientMonitor::setRequester(PvaClientMonitorRequesterPtr const & pvaClientMonitorrRequester)
{
this->pvaClientMonitorRequester = pvaClientMonitorrRequester;
}
void PvaClientMonitor::start()
{
if(isDestroyed) throw std::runtime_error("pvaClientMonitor was destroyed");
if(connectState==monitorStarted) return;
if(connectState==connectIdle) connect();
if(connectState!=connected) throw std::runtime_error("PvaClientMonitor::start illegal state");
connectState = monitorStarted;
monitor->start();
}
void PvaClientMonitor::stop()
{
if(isDestroyed) throw std::runtime_error("pvaClientMonitor was destroyed");
if(connectState!=monitorStarted) return;
connectState = connected;
monitor->stop();
}
bool PvaClientMonitor::poll()
{
checkMonitorState();
if(connectState!=monitorStarted) throw std::runtime_error("PvaClientMonitor::poll illegal state");
if(userPoll) throw std::runtime_error("PvaClientMonitor::poll did not release last");
monitorElement = monitor->poll();
if(!monitorElement) return false;
userPoll = true;
pvaClientData->setData(monitorElement);
return true;
}
bool PvaClientMonitor::waitEvent(double secondsToWait)
{
if(isDestroyed) throw std::runtime_error("pvaClientMonitor was destroyed");
if(connectState!=monitorStarted) throw std::runtime_error("PvaClientMonitor::poll illegal state");
if(poll()) return true;
userWait = true;
if(secondsToWait==0.0) {
waitForEvent.wait();
} else {
waitForEvent.wait(secondsToWait);
}
userWait = false;
return poll();
}
void PvaClientMonitor::releaseEvent()
{
if(isDestroyed) throw std::runtime_error("pvaClientMonitor was destroyed");
if(connectState!=monitorStarted) throw std::runtime_error("PvaClientMonitor::poll illegal state");
if(!userPoll) throw std::runtime_error("PvaClientMonitor::releaseEvent did not call poll");
userPoll = false;
monitor->release(monitorElement);
}
PvaClientMonitorDataPtr PvaClientMonitor::getData()
{
checkMonitorState();
return pvaClientData;
}
PvaClientMonitorPtr PvaClientMonitor::create(
PvaClientPtr const &pvaClient,
PvaClientChannelPtr const & pvaClientChannel,
Channel::shared_pointer const & channel,
PVStructurePtr const &pvRequest)
{
PvaClientMonitorPtr epv(new PvaClientMonitor(pvaClient,pvaClientChannel,channel,pvRequest));
return epv;
}
}}

52
src/easyMonitorData.cpp → src/pvaClientMonitorData.cpp
View File

@@ -1,4 +1,4 @@
/* easyMonitorData.cpp */
/* pvaClientMonitorData.cpp */
/**
* Copyright - See the COPYRIGHT that is included with this distribution.
* EPICS pvData is distributed subject to a Software License Agreement found
@@ -13,7 +13,7 @@
#include <typeinfo>
#include <sstream>
#include <pv/easyPVA.h>
#include <pv/pvaClient.h>
#include <pv/createRequest.h>
#include <pv/convert.h>
@@ -23,7 +23,7 @@ using namespace epics::pvData;
using namespace epics::pvAccess;
using namespace std;
namespace epics { namespace easyPVA {
namespace epics { namespace pvaClient {
typedef std::tr1::shared_ptr<PVArray> PVArrayPtr;
@@ -39,50 +39,50 @@ static string noScalarArray("value is not a scalarArray");
static string notDoubleArray("value is not a doubleArray");
static string notStringArray("value is not a stringArray");
EasyMonitorDataPtr EasyMonitorData::create(StructureConstPtr const & structure)
PvaClientMonitorDataPtr PvaClientMonitorData::create(StructureConstPtr const & structure)
{
EasyMonitorDataPtr epv(new EasyMonitorData(structure));
PvaClientMonitorDataPtr epv(new PvaClientMonitorData(structure));
return epv;
}
EasyMonitorData::EasyMonitorData(StructureConstPtr const & structure)
PvaClientMonitorData::PvaClientMonitorData(StructureConstPtr const & structure)
: structure(structure)
{}
void EasyMonitorData::checkValue()
void PvaClientMonitorData::checkValue()
{
if(pvValue) return;
throw std::runtime_error(messagePrefix + noValue);
}
void EasyMonitorData::setMessagePrefix(std::string const & value)
void PvaClientMonitorData::setMessagePrefix(std::string const & value)
{
messagePrefix = value + " ";
}
StructureConstPtr EasyMonitorData::getStructure()
StructureConstPtr PvaClientMonitorData::getStructure()
{return structure;}
PVStructurePtr EasyMonitorData::getPVStructure()
PVStructurePtr PvaClientMonitorData::getPVStructure()
{
if(pvStructure) return pvStructure;
throw std::runtime_error(messagePrefix + noStructure);
}
BitSetPtr EasyMonitorData::getChangedBitSet()
BitSetPtr PvaClientMonitorData::getChangedBitSet()
{
if(!changedBitSet) throw std::runtime_error(messagePrefix + noStructure);
return changedBitSet;
}
BitSetPtr EasyMonitorData::getOverrunBitSet()
BitSetPtr PvaClientMonitorData::getOverrunBitSet()
{
if(!overrunBitSet) throw std::runtime_error(messagePrefix + noStructure);
return overrunBitSet;
}
std::ostream & EasyMonitorData::showChanged(std::ostream & out)
std::ostream & PvaClientMonitorData::showChanged(std::ostream & out)
{
if(!changedBitSet) throw std::runtime_error(messagePrefix + noStructure);
size_t nextSet = changedBitSet->nextSetBit(0);
@@ -100,7 +100,7 @@ std::ostream & EasyMonitorData::showChanged(std::ostream & out)
return out;
}
std::ostream & EasyMonitorData::showOverrun(std::ostream & out)
std::ostream & PvaClientMonitorData::showOverrun(std::ostream & out)
{
if(!overrunBitSet) throw std::runtime_error(messagePrefix + noStructure);
size_t nextSet = overrunBitSet->nextSetBit(0);
@@ -118,7 +118,7 @@ std::ostream & EasyMonitorData::showOverrun(std::ostream & out)
return out;
}
void EasyMonitorData::setData(MonitorElementPtr const & monitorElement)
void PvaClientMonitorData::setData(MonitorElementPtr const & monitorElement)
{
pvStructure = monitorElement->pvStructurePtr;
changedBitSet = monitorElement->changedBitSet;
@@ -126,33 +126,33 @@ void EasyMonitorData::setData(MonitorElementPtr const & monitorElement)
pvValue = pvStructure->getSubField("value");
}
bool EasyMonitorData::hasValue()
bool PvaClientMonitorData::hasValue()
{
if(!pvValue) return false;
return true;
}
bool EasyMonitorData::isValueScalar()
bool PvaClientMonitorData::isValueScalar()
{
if(!pvValue) return false;
if(pvValue->getField()->getType()==scalar) return true;
return false;
}
bool EasyMonitorData::isValueScalarArray()
bool PvaClientMonitorData::isValueScalarArray()
{
if(!pvValue) return false;
if(pvValue->getField()->getType()==scalarArray) return true;
return false;
}
PVFieldPtr EasyMonitorData::getValue()
PVFieldPtr PvaClientMonitorData::getValue()
{
checkValue();
return pvValue;
}
PVScalarPtr EasyMonitorData::getScalarValue()
PVScalarPtr PvaClientMonitorData::getScalarValue()
{
checkValue();
PVScalarPtr pv = pvStructure->getSubField<PVScalar>("value");
@@ -162,7 +162,7 @@ PVScalarPtr EasyMonitorData::getScalarValue()
return pv;
}
PVArrayPtr EasyMonitorData::getArrayValue()
PVArrayPtr PvaClientMonitorData::getArrayValue()
{
checkValue();
PVArrayPtr pv = pvStructure->getSubField<PVArray>("value");
@@ -172,7 +172,7 @@ PVArrayPtr EasyMonitorData::getArrayValue()
return pv;
}
PVScalarArrayPtr EasyMonitorData::getScalarArrayValue()
PVScalarArrayPtr PvaClientMonitorData::getScalarArrayValue()
{
checkValue();
PVScalarArrayPtr pv = pvStructure->getSubField<PVScalarArray>("value");
@@ -182,7 +182,7 @@ PVScalarArrayPtr EasyMonitorData::getScalarArrayValue()
return pv;
}
double EasyMonitorData::getDouble()
double PvaClientMonitorData::getDouble()
{
PVScalarPtr pvScalar = getScalarValue();
ScalarType scalarType = pvScalar->getScalar()->getScalarType();
@@ -196,13 +196,13 @@ double EasyMonitorData::getDouble()
return convert->toDouble(pvScalar);
}
string EasyMonitorData::getString()
string PvaClientMonitorData::getString()
{
PVScalarPtr pvScalar = getScalarValue();
return convert->toString(pvScalar);
}
shared_vector<const double> EasyMonitorData::getDoubleArray()
shared_vector<const double> PvaClientMonitorData::getDoubleArray()
{
checkValue();
PVDoubleArrayPtr pv = pvStructure->getSubField<PVDoubleArray>("value");
@@ -212,7 +212,7 @@ shared_vector<const double> EasyMonitorData::getDoubleArray()
return pv->view();
}
shared_vector<const string> EasyMonitorData::getStringArray()
shared_vector<const string> PvaClientMonitorData::getStringArray()
{
checkValue();
PVStringArrayPtr pv = pvStructure->getSubField<PVStringArray>("value");

165
src/pvaClientMultiChannel.cpp Normal file
View File

@@ -0,0 +1,165 @@
/* pvaClientMultiChannel.cpp */
/**
* Copyright - See the COPYRIGHT that is included with this distribution.
* EPICS pvData is distributed subject to a Software License Agreement found
* in file LICENSE that is included with this distribution.
*/
/**
* @author mrk
* @date 2015.02
*/
#define epicsExportSharedSymbols
#include <map>
#include <sstream>
#include <pv/event.h>
#include <pv/lock.h>
#include <pv/pvaClient.h>
#include <pv/createRequest.h>
using std::tr1::static_pointer_cast;
using namespace epics::pvData;
using namespace epics::pvAccess;
using namespace std;
namespace epics { namespace pvaClient {
PvaClientMultiChannel::PvaClientMultiChannel(
PvaClientPtr const &pvaClient,
PVStringArrayPtr const & channelName,
string const & providerName)
: pvaClient(pvaClient),
channelName(channelName),
providerName(providerName),
numChannel(channelName->getLength()),
isConnected(getPVDataCreate()->createPVScalarArray<PVBooleanArray>()),
isDestroyed(false)
{
}
PvaClientMultiChannel::~PvaClientMultiChannel()
{
destroy();
}
void PvaClientMultiChannel::destroy()
{
{
Lock xx(mutex);
if(isDestroyed) return;
isDestroyed = true;
}
pvaClientChannelArray.reset();
}
PVStringArrayPtr PvaClientMultiChannel::getChannelNames()
{
if(isDestroyed) throw std::runtime_error("pvaClientMultiChannel was destroyed");
return channelName;
}
Status PvaClientMultiChannel::connect(double timeout,size_t maxNotConnected)
{
if(isDestroyed) throw std::runtime_error("pvaClientMultiChannel was destroyed");
if(pvaClientChannelArray) throw std::runtime_error("pvaClientMultiChannel already connected");
PvaClientPtr pvaClient = this->pvaClient.lock();
if(!pvaClient) return Status(Status::STATUSTYPE_ERROR,"pvaClient is gone");
shared_vector<PvaClientChannelPtr> pvaClientChannel(numChannel,PvaClientChannelPtr());
PVStringArray::const_svector channelNames = channelName->view();
shared_vector<boolean> isConnected(numChannel,false);
for(size_t i=0; i< numChannel; ++i) {
pvaClientChannel[i] = pvaClient->createChannel(channelNames[i],providerName);
pvaClientChannel[i]->issueConnect();
}
Status returnStatus = Status::Ok;
Status status = Status::Ok;
size_t numBad = 0;
for(size_t i=0; i< numChannel; ++i) {
if(numBad==0) {
status = pvaClientChannel[i]->waitConnect(timeout);
} else {
status = pvaClientChannel[i]->waitConnect(.001);
}
if(status.isOK()) {
++numConnected;
isConnected[i] = true;
continue;
}
if(returnStatus.isOK()) returnStatus = status;
++numBad;
if(numBad>maxNotConnected) break;
}
pvaClientChannelArray = PvaClientChannelArrayPtr(new PvaClientChannelArray(freeze(pvaClientChannel)));
this->isConnected->replace(freeze(isConnected));
return numBad>maxNotConnected ? returnStatus : Status::Ok;
}
bool PvaClientMultiChannel::allConnected()
{
if(isDestroyed) throw std::runtime_error("pvaClientMultiChannel was destroyed");
if(!pvaClientChannelArray) throw std::runtime_error("pvaClientMultiChannel not connected");
if(numConnected==numChannel) return true;
return (numConnected==numChannel) ? true : false;
}
bool PvaClientMultiChannel::connectionChange()
{
if(isDestroyed) throw std::runtime_error("pvaClientMultiChannel was destroyed");
if(!pvaClientChannelArray) throw std::runtime_error("pvaClientMultiChannel not connected");
if(numConnected==numChannel) return true;
PVBooleanArray::const_svector isConnected = this->isConnected->view();
shared_vector<const PvaClientChannelPtr> channels = *pvaClientChannelArray.get();
for(size_t i=0; i<numChannel; ++i) {
const PvaClientChannelPtr pvaClientChannel = channels[i];
Channel::shared_pointer channel = pvaClientChannel->getChannel();
Channel::ConnectionState stateNow = channel->getConnectionState();
bool connectedNow = stateNow==Channel::CONNECTED ? true : false;
if(connectedNow!=isConnected[i]) return true;
}
return false;
}
PVBooleanArrayPtr PvaClientMultiChannel::getIsConnected()
{
if(isDestroyed) throw std::runtime_error("pvaClientMultiChannel was destroyed");
if(!pvaClientChannelArray) throw std::runtime_error("pvaClientMultiChannel not connected");
if(!connectionChange()) return isConnected;
shared_vector<boolean> isConnected(numChannel,false);
shared_vector<const PvaClientChannelPtr> channels = *pvaClientChannelArray.get();
for(size_t i=0; i<numChannel; ++i) {
const PvaClientChannelPtr pvaClientChannel = channels[i];
Channel::shared_pointer channel = pvaClientChannel->getChannel();
Channel::ConnectionState stateNow = channel->getConnectionState();
if(stateNow==Channel::CONNECTED) isConnected[i] = true;
}
this->isConnected->replace(freeze(isConnected));
return this->isConnected;
}
PvaClientChannelArrayWPtr PvaClientMultiChannel::getPvaClientChannelArray()
{
if(isDestroyed) throw std::runtime_error("pvaClientMultiChannel was destroyed");
if(!pvaClientChannelArray) throw std::runtime_error("pvaClientMultiChannel not connected");
return pvaClientChannelArray;
}
PvaClient::weak_pointer PvaClientMultiChannel::getPvaClient()
{
if(isDestroyed) throw std::runtime_error("pvaClientMultiChannel was destroyed");
return pvaClient;
}
PvaClientMultiChannelPtr PvaClientMultiChannel::create(
PvaClientPtr const &pvaClient,
PVStringArrayPtr const & channelNames,
string const & providerName)
{
PvaClientMultiChannelPtr channel(new PvaClientMultiChannel(pvaClient,channelNames,providerName));
return channel;
}
}}

139
src/pvaClientMultiDouble.cpp Normal file
View File

@@ -0,0 +1,139 @@
/* pvaClientMultiDouble.cpp */
/**
* Copyright - See the COPYRIGHT that is included with this distribution.
* EPICS pvData is distributed subject to a Software License Agreement found
* in file LICENSE that is included with this distribution.
*/
/**
* @author mrk
* @date 2015.03
*/
#define epicsExportSharedSymbols
#include <pv/pvaClientMultiDouble.h>
using std::tr1::static_pointer_cast;
using namespace epics::pvData;
using namespace epics::pvAccess;
using namespace std;
namespace epics { namespace pvaClient {
PvaClientMultiDoublePtr PvaClientMultiDouble::create(
PvaClientPtr const & pvaClient,
PVStringArrayPtr const & channelName,
double timeout,
std::string const & providerName)
{
PvaClientMultiChannelPtr pvaClientMultiChannel(
PvaClientMultiChannel::create(pvaClient,channelName,providerName));
Status status = pvaClientMultiChannel->connect(timeout,0);
if(!status.isOK()) throw std::runtime_error(status.getMessage());
return PvaClientMultiDoublePtr(new PvaClientMultiDouble(pvaClientMultiChannel));
}
PvaClientMultiDouble::PvaClientMultiDouble(PvaClientMultiChannelPtr const &pvaClientMultiChannel)
:
pvaClientMultiChannel(pvaClientMultiChannel)
{}
PvaClientMultiDouble::~PvaClientMultiDouble()
{
}
void PvaClientMultiDouble::createGet()
{
PvaClientChannelArrayPtr pvaClientChannelArray = pvaClientMultiChannel->getPvaClientChannelArray().lock();
if(!pvaClientChannelArray) throw std::runtime_error("pvaClientChannelArray is gone");
shared_vector<const PvaClientChannelPtr> pvaClientChannels = *pvaClientChannelArray;
size_t numChannel = pvaClientChannels.size();
pvaClientGet = std::vector<PvaClientGetPtr>(numChannel,PvaClientGetPtr());
bool allOK = true;
string message;
for(size_t i=0; i<numChannel; ++i)
{
pvaClientGet[i] = pvaClientChannels[i]->createGet("value");
pvaClientGet[i]->issueConnect();
}
for(size_t i=0; i<numChannel; ++i)
{
Status status = pvaClientGet[i]->waitConnect();
if(!status.isOK()) {
message = "connect status " + status.getMessage();
allOK = false;
break;
}
}
if(!allOK) throw std::runtime_error(message);
}
void PvaClientMultiDouble::createPut()
{
PvaClientChannelArrayPtr pvaClientChannelArray = pvaClientMultiChannel->getPvaClientChannelArray().lock();
if(!pvaClientChannelArray) throw std::runtime_error("pvaClientChannelArray is gone");
shared_vector<const PvaClientChannelPtr> pvaClientChannels = *pvaClientChannelArray;
size_t numChannel = pvaClientChannels.size();
pvaClientPut = std::vector<PvaClientPutPtr>(numChannel,PvaClientPutPtr());
bool allOK = true;
string message;
for(size_t i=0; i<numChannel; ++i)
{
pvaClientPut[i] = pvaClientChannels[i]->createPut("value");
pvaClientPut[i]->issueConnect();
}
for(size_t i=0; i<numChannel; ++i)
{
Status status = pvaClientPut[i]->waitConnect();
if(!status.isOK()) {
message = "connect status " + status.getMessage();
allOK = false;
break;
}
}
if(!allOK) throw std::runtime_error(message);
}
epics::pvData::shared_vector<double> PvaClientMultiDouble::get()
{
if(pvaClientGet.empty()) createGet();
shared_vector<const string> channelNames = pvaClientMultiChannel->getChannelNames()->view();
size_t numChannel = channelNames.size();
epics::pvData::shared_vector<double> data(channelNames.size());
for(size_t i=0; i<numChannel; ++i)
{
pvaClientGet[i]->issueGet();
}
for(size_t i=0; i<numChannel; ++i)
{
Status status = pvaClientGet[i]->waitGet();
if(!status.isOK()) {
string message = channelNames[i] + " " + status.getMessage();
throw std::runtime_error(message);
}
data[i] = pvaClientGet[i]->getData()->getDouble();
}
return data;
}
void PvaClientMultiDouble::put(shared_vector<double> const &value)
{
if(pvaClientPut.empty()) createPut();
shared_vector<const string> channelNames = pvaClientMultiChannel->getChannelNames()->view();
size_t numChannel = channelNames.size();
for(size_t i=0; i<numChannel; ++i)
{
pvaClientPut[i]->getData()->putDouble(value[i]);
pvaClientPut[i]->issuePut();
}
for(size_t i=0; i<numChannel; ++i)
{
Status status = pvaClientPut[i]->waitPut();
if(!status.isOK()) {
string message = channelNames[i] + " " + status.getMessage();
throw std::runtime_error(message);
}
}
}
}}

46
src/easyMultiDouble.h → src/pvaClientMultiDouble.h
View File

@@ -1,4 +1,4 @@
/* easyMultiDouble.h */
/* pvaClientMultiDouble.h */
/**
* Copyright - See the COPYRIGHT that is included with this distribution.
* EPICS pvData is distributed subject to a Software License Agreement found
@@ -8,20 +8,20 @@
* @author mrk
* @date 2015.02
*/
#ifndef EASYMULTIDOUBLE_H
#define EASYMULTIDOUBLE_H
#ifndef PVACLIENTMULTIDOUBLE_H
#define PVACLIENTMULTIDOUBLE_H
#ifdef epicsExportSharedSymbols
# define easyPVAEpicsExportSharedSymbols
# define pvaClientEpicsExportSharedSymbols
# undef epicsExportSharedSymbols
#endif
#include <pv/easyPVA.h>
#include <pv/pvaClient.h>
namespace epics { namespace easyPVA {
namespace epics { namespace pvaClient {
class EasyMultiDouble;
typedef std::tr1::shared_ptr<EasyMultiDouble> EasyMultiDoublePtr;
class PvaClientMultiDouble;
typedef std::tr1::shared_ptr<PvaClientMultiDouble> PvaClientMultiDoublePtr;
/**
* @brief Support for multiple channels where each channel has a value field that is a scalar double.
@@ -29,27 +29,27 @@ typedef std::tr1::shared_ptr<EasyMultiDouble> EasyMultiDoublePtr;
*
* @author mrk
*/
class epicsShareClass EasyMultiDouble
class epicsShareClass PvaClientMultiDouble
{
public:
POINTER_DEFINITIONS(EasyMultiDouble);
POINTER_DEFINITIONS(PvaClientMultiDouble);
/**
* @brief Create a EasyMultiDouble.
* @param &easyPVA Interface to EasyPVA
* @brief Create a PvaClientMultiDouble.
* @param &pvaClient Interface to PvaClient
* @param channelName PVStringArray of channelNames.
* @param timeout The timeout in seconds for connecting.
* @param providerName The name of the channelProvider for each channel.
* @return The interface to EasyMultiDouble.
* @return The interface to PvaClientMultiDouble.
*/
static EasyMultiDoublePtr create(
EasyPVAPtr const & easyPVA,
static PvaClientMultiDoublePtr create(
PvaClientPtr const & pvaClient,
epics::pvData::PVStringArrayPtr const & channelName,
double timeout = 5.0,
std::string const & providerName = "pva");
/**
* @brief destructor
*/
~EasyMultiDouble();
~PvaClientMultiDouble();
/**
* @brief destroy any resources used.
*/
@@ -64,18 +64,18 @@ public:
* @param value The data.
*/
void put(epics::pvData::shared_vector<double> const &value);
EasyMultiChannelPtr getEasyMultiChannel();
PvaClientMultiChannelPtr getPvaClientMultiChannel();
private:
EasyMultiDouble(
EasyMultiChannelPtr const & channelName);
PvaClientMultiDouble(
PvaClientMultiChannelPtr const & channelName);
void createGet();
void createPut();
EasyMultiChannelPtr easyMultiChannel;
std::vector<EasyGetPtr> easyGet;
std::vector<EasyPutPtr> easyPut;
PvaClientMultiChannelPtr pvaClientMultiChannel;
std::vector<PvaClientGetPtr> pvaClientGet;
std::vector<PvaClientPutPtr> pvaClientPut;
};
}}
#endif // EASYMULTIDOUBLE_H
#endif // PVACLIENTMULTIDOUBLE_H

91
src/easyNTMultiChannel.cpp → src/pvaClientNTMultiChannel.cpp
View File

@@ -1,4 +1,4 @@
/* easyNTMultiChannel.cpp */
/* pvaClientNTMultiChannel.cpp */
/**
* Copyright - See the COPYRIGHT that is included with this distribution.
* EPICS pvData is distributed subject to a Software License Agreement found
@@ -9,7 +9,8 @@
* @date 2015.03
*/
#include <pv/easyNTMultiChannel.h>
#define epicsExportSharedSymbols
#include <pv/pvaClientNTMultiChannel.h>
using std::tr1::static_pointer_cast;
using namespace epics::pvData;
@@ -17,44 +18,44 @@ using namespace epics::pvAccess;
using namespace epics::nt;
using namespace std;
namespace epics { namespace easyPVA {
namespace epics { namespace pvaClient {
EasyNTMultiChannelPtr EasyNTMultiChannel::create(
EasyPVAPtr const & easyPVA,
PvaClientNTMultiChannelPtr PvaClientNTMultiChannel::create(
PvaClientPtr const & pvaClient,
PVStringArrayPtr const & channelName,
StructureConstPtr const &structure,
double timeout,
std::string const & providerName)
{
EasyMultiChannelPtr easyMultiChannel(
EasyMultiChannel::create(easyPVA,channelName,providerName));
Status status = easyMultiChannel->connect(timeout,0);
PvaClientMultiChannelPtr pvaClientMultiChannel(
PvaClientMultiChannel::create(pvaClient,channelName,providerName));
Status status = pvaClientMultiChannel->connect(timeout,0);
if(!status.isOK()) throw std::runtime_error(status.getMessage());
if(!NTMultiChannel::is_a(structure)) throw std::runtime_error("structure is not valid");
PVStructurePtr pvStructure = getPVDataCreate()->createPVStructure(structure);
pvStructure->getSubField<PVStringArray>("channelName")->
replace(easyMultiChannel->getChannelNames()->view());
replace(pvaClientMultiChannel->getChannelNames()->view());
pvStructure->getSubField<PVBooleanArray>("isConnected")->
replace(easyMultiChannel->getIsConnected()->view());
replace(pvaClientMultiChannel->getIsConnected()->view());
NTMultiChannelPtr ntMultiChannel(NTMultiChannel::wrap(pvStructure));
return EasyNTMultiChannelPtr(new EasyNTMultiChannel(easyMultiChannel,ntMultiChannel));
return PvaClientNTMultiChannelPtr(new PvaClientNTMultiChannel(pvaClientMultiChannel,ntMultiChannel));
}
EasyNTMultiChannel::EasyNTMultiChannel(
EasyMultiChannelPtr const &easyMultiChannel,
PvaClientNTMultiChannel::PvaClientNTMultiChannel(
PvaClientMultiChannelPtr const &pvaClientMultiChannel,
NTMultiChannelPtr const &ntMultiChannel)
:
easyMultiChannel(easyMultiChannel),
pvaClientMultiChannel(pvaClientMultiChannel),
ntMultiChannel(ntMultiChannel),
pvUnionArray(ntMultiChannel->getPVStructure()->getSubField<PVUnionArray>("value")),
pvDataCreate(getPVDataCreate())
{}
EasyNTMultiChannel::~EasyNTMultiChannel()
PvaClientNTMultiChannel::~PvaClientNTMultiChannel()
{
}
void EasyNTMultiChannel::createGet()
void PvaClientNTMultiChannel::createGet()
{
PVStructurePtr pvStructure = ntMultiChannel->getPVStructure();
bool getAlarm = false;
@@ -68,21 +69,21 @@ void EasyNTMultiChannel::createGet()
string request = "value";
if(getAlarm) request += ",alarm";
if(getTimeStamp) request += ",timeStamp";
EasyChannelArrayPtr easyChannelArray = easyMultiChannel->getEasyChannelArray().lock();
if(!easyChannelArray) throw std::runtime_error("easyChannelArray is gone");
shared_vector<const EasyChannelPtr> easyChannels = *easyChannelArray;
size_t numChannel = easyChannels.size();
easyGet = std::vector<EasyGetPtr>(numChannel,EasyGetPtr());
PvaClientChannelArrayPtr pvaClientChannelArray = pvaClientMultiChannel->getPvaClientChannelArray().lock();
if(!pvaClientChannelArray) throw std::runtime_error("pvaClientChannelArray is gone");
shared_vector<const PvaClientChannelPtr> pvaClientChannels = *pvaClientChannelArray;
size_t numChannel = pvaClientChannels.size();
pvaClientGet = std::vector<PvaClientGetPtr>(numChannel,PvaClientGetPtr());
bool allOK = true;
string message;
for(size_t i=0; i<numChannel; ++i)
{
easyGet[i] = easyChannels[i]->createGet(request);
easyGet[i]->issueConnect();
pvaClientGet[i] = pvaClientChannels[i]->createGet(request);
pvaClientGet[i]->issueConnect();
}
for(size_t i=0; i<numChannel; ++i)
{
Status status = easyGet[i]->waitConnect();
Status status = pvaClientGet[i]->waitConnect();
if(!status.isOK()) {
message = "connect status " + status.getMessage();
allOK = false;
@@ -93,23 +94,23 @@ void EasyNTMultiChannel::createGet()
}
void EasyNTMultiChannel::createPut()
void PvaClientNTMultiChannel::createPut()
{
EasyChannelArrayPtr easyChannelArray = easyMultiChannel->getEasyChannelArray().lock();
if(!easyChannelArray) throw std::runtime_error("easyChannelArray is gone");
shared_vector<const EasyChannelPtr> easyChannels = *easyChannelArray;
size_t numChannel = easyChannels.size();
easyPut = std::vector<EasyPutPtr>(numChannel,EasyPutPtr());
PvaClientChannelArrayPtr pvaClientChannelArray = pvaClientMultiChannel->getPvaClientChannelArray().lock();
if(!pvaClientChannelArray) throw std::runtime_error("pvaClientChannelArray is gone");
shared_vector<const PvaClientChannelPtr> pvaClientChannels = *pvaClientChannelArray;
size_t numChannel = pvaClientChannels.size();
pvaClientPut = std::vector<PvaClientPutPtr>(numChannel,PvaClientPutPtr());
bool allOK = true;
string message;
for(size_t i=0; i<numChannel; ++i)
{
easyPut[i] = easyChannels[i]->createPut("value");
easyPut[i]->issueConnect();
pvaClientPut[i] = pvaClientChannels[i]->createPut("value");
pvaClientPut[i]->issueConnect();
}
for(size_t i=0; i<numChannel; ++i)
{
Status status = easyPut[i]->waitConnect();
Status status = pvaClientPut[i]->waitConnect();
if(!status.isOK()) {
message = "connect status " + status.getMessage();
allOK = false;
@@ -119,11 +120,11 @@ void EasyNTMultiChannel::createPut()
if(!allOK) throw std::runtime_error(message);
}
NTMultiChannelPtr EasyNTMultiChannel::get()
NTMultiChannelPtr PvaClientNTMultiChannel::get()
{
if(easyGet.empty()) createGet();
if(pvaClientGet.empty()) createGet();
PVStructurePtr pvStructure = ntMultiChannel->getPVStructure();
shared_vector<const string> channelNames = easyMultiChannel->getChannelNames()->view();
shared_vector<const string> channelNames = pvaClientMultiChannel->getChannelNames()->view();
size_t numChannel = channelNames.size();
bool severityExists = false;
bool statusExists = false;
@@ -158,16 +159,16 @@ NTMultiChannelPtr EasyNTMultiChannel::get()
shared_vector<PVUnionPtr> valueVector(numChannel);
for(size_t i=0; i<numChannel; ++i)
{
easyGet[i]->issueGet();
pvaClientGet[i]->issueGet();
}
for(size_t i=0; i<numChannel; ++i)
{
Status stat = easyGet[i]->waitGet();
Status stat = pvaClientGet[i]->waitGet();
if(!stat.isOK()) {
string message = channelNames[i] + " " + stat.getMessage();
throw std::runtime_error(message);
}
PVStructurePtr pvStructure = easyGet[i]->getData()->getPVStructure();
PVStructurePtr pvStructure = pvaClientGet[i]->getData()->getPVStructure();
PVFieldPtr pvField = pvStructure->getSubField("value");
if(!pvField) {
string message = channelNames[i] + " no value field";
@@ -228,10 +229,10 @@ NTMultiChannelPtr EasyNTMultiChannel::get()
return ntMultiChannel;
}
void EasyNTMultiChannel::put(NTMultiChannelPtr const &value)
void PvaClientNTMultiChannel::put(NTMultiChannelPtr const &value)
{
if(easyPut.empty()) createPut();
shared_vector<const string> channelNames = easyMultiChannel->getChannelNames()->view();
if(pvaClientPut.empty()) createPut();
shared_vector<const string> channelNames = pvaClientMultiChannel->getChannelNames()->view();
size_t numChannel = channelNames.size();
PVUnionArrayPtr pvValue = value->getPVStructure()->
getSubField<PVUnionArray>("value");
@@ -240,7 +241,7 @@ void EasyNTMultiChannel::put(NTMultiChannelPtr const &value)
{
try {
PVFieldPtr pvFrom = valueVector[i]->get();
PVFieldPtr pvTo = easyPut[i]->getData()->getValue();
PVFieldPtr pvTo = pvaClientPut[i]->getData()->getValue();
Type typeFrom = pvFrom->getField()->getType();
Type typeTo = pvTo->getField()->getType();
if(typeFrom==typeTo) {
@@ -248,7 +249,7 @@ void EasyNTMultiChannel::put(NTMultiChannelPtr const &value)
pvTo->copy(*pvFrom);
}
}
easyPut[i]->issuePut();
pvaClientPut[i]->issuePut();
} catch (std::exception e) {
string message = channelNames[i] + " " + e.what();
throw std::runtime_error(message);
@@ -256,7 +257,7 @@ void EasyNTMultiChannel::put(NTMultiChannelPtr const &value)
}
for(size_t i=0; i<numChannel; ++i)
{
Status status = easyPut[i]->waitPut();
Status status = pvaClientPut[i]->waitPut();
if(!status.isOK()) {
string message = channelNames[i] + " " + status.getMessage();
throw std::runtime_error(message);

48
src/easyNTMultiChannel.h → src/pvaClientNTMultiChannel.h
View File

@@ -1,4 +1,4 @@
/* easyNTMultiChannel.h */
/* pvaClientNTMultiChannel.h */
/**
* Copyright - See the COPYRIGHT that is included with this distribution.
* EPICS pvData is distributed subject to a Software License Agreement found
@@ -8,20 +8,20 @@
* @author mrk
* @date 2015.02
*/
#ifndef EASYNTMULTIChannel_H
#define EASYNTMULTIChannel_H
#ifndef PVACLIENTNTMULTIChannel_H
#define PVACLIENTNTMULTIChannel_H
#ifdef epicsExportSharedSymbols
# define easyPVAEpicsExportSharedSymbols
# define pvaClientEpicsExportSharedSymbols
# undef epicsExportSharedSymbols
#endif
#include <pv/easyPVA.h>
#include <pv/pvaClient.h>
namespace epics { namespace easyPVA {
namespace epics { namespace pvaClient {
class EasyNTMultiChannel;
typedef std::tr1::shared_ptr<EasyNTMultiChannel> EasyNTMultiChannelPtr;
class PvaClientNTMultiChannel;
typedef std::tr1::shared_ptr<PvaClientNTMultiChannel> PvaClientNTMultiChannelPtr;
/**
* @brief Support for multiple channels where each channel has a value field that
@@ -31,21 +31,21 @@ typedef std::tr1::shared_ptr<EasyNTMultiChannel> EasyNTMultiChannelPtr;
*
* @author mrk
*/
class epicsShareClass EasyNTMultiChannel
class epicsShareClass PvaClientNTMultiChannel
{
public:
POINTER_DEFINITIONS(EasyNTMultiChannel);
POINTER_DEFINITIONS(PvaClientNTMultiChannel);
/**
* @brief Create a EasyNTMultiChannel.
* @param &easyPVA Interface to EasyPVA
* @brief Create a PvaClientNTMultiChannel.
* @param &pvaClient Interface to PvaClient
* @param channelName PVStringArray of channelNames.
* @param structure valid NTMultiChannel structure.
* @param timeout Timeout for connecting.
* @param providerName The provider for each channel.
* @return The interface to EasyNTMultiChannel.
* @return The interface to PvaClientNTMultiChannel.
*/
static EasyNTMultiChannelPtr create(
EasyPVAPtr const & easyPVA,
static PvaClientNTMultiChannelPtr create(
PvaClientPtr const & pvaClient,
epics::pvData::PVStringArrayPtr const & channelName,
epics::pvData::StructureConstPtr const & structure,
double timeout = 5.0,
@@ -53,7 +53,7 @@ public:
/**
* @brief destructor
*/
~EasyNTMultiChannel();
~PvaClientNTMultiChannel();
/**
* @brief destroy any resources used.
*/
@@ -69,23 +69,23 @@ public:
*/
void put(epics::nt::NTMultiChannelPtr const &value);
/**
* @brief Get the EasyMultiChannel.
* @brief Get the PvaClientMultiChannel.
* @return The interface.
*/
EasyMultiChannelPtr getEasyMultiChannel();
PvaClientMultiChannelPtr getPvaClientMultiChannel();
private:
EasyNTMultiChannel(
EasyMultiChannelPtr const & channelName,
PvaClientNTMultiChannel(
PvaClientMultiChannelPtr const & channelName,
epics::nt::NTMultiChannelPtr const &ntMultiChannel);
void createGet();
void createPut();
EasyMultiChannelPtr easyMultiChannel;
PvaClientMultiChannelPtr pvaClientMultiChannel;
epics::nt::NTMultiChannelPtr ntMultiChannel;
epics::pvData::PVUnionArrayPtr pvUnionArray;
epics::pvData::PVDataCreatePtr pvDataCreate;
std::vector<EasyGetPtr> easyGet;
std::vector<EasyPutPtr> easyPut;
std::vector<PvaClientGetPtr> pvaClientGet;
std::vector<PvaClientPutPtr> pvaClientPut;
epics::pvData::shared_vector<epics::pvData::int32> severity;
epics::pvData::shared_vector<epics::pvData::int32> status;
epics::pvData::shared_vector<std::string> message;
@@ -100,4 +100,4 @@ private:
}}
#endif // EASYNTMULTIChannel_H
#endif // PVACLIENTNTMULTIChannel_H

106
src/easyProcess.cpp → src/pvaClientProcess.cpp
View File

@@ -1,4 +1,4 @@
/* easyProcess.cpp */
/* pvaClientProcess.cpp */
/**
* Copyright - See the COPYRIGHT that is included with this distribution.
* EPICS pvData is distributed subject to a Software License Agreement found
@@ -12,43 +12,43 @@
#include <sstream>
#include <pv/event.h>
#include <pv/easyPVA.h>
#include <pv/pvaClient.h>
using std::tr1::static_pointer_cast;
using namespace epics::pvData;
using namespace epics::pvAccess;
using namespace std;
namespace epics { namespace easyPVA {
namespace epics { namespace pvaClient {
class ChannelProcessRequesterImpl : public ChannelProcessRequester
{
EasyProcess * easyProcess;
PvaClientProcess * pvaClientProcess;
public:
ChannelProcessRequesterImpl(EasyProcess * easyProcess)
: easyProcess(easyProcess) {}
ChannelProcessRequesterImpl(PvaClientProcess * pvaClientProcess)
: pvaClientProcess(pvaClientProcess) {}
string getRequesterName()
{return easyProcess->getRequesterName();}
{return pvaClientProcess->getRequesterName();}
void message(string const & message,MessageType messageType)
{easyProcess->message(message,messageType);}
{pvaClientProcess->message(message,messageType);}
void channelProcessConnect(
const Status& status,
ChannelProcess::shared_pointer const & channelProcess)
{easyProcess->channelProcessConnect(status,channelProcess);}
{pvaClientProcess->channelProcessConnect(status,channelProcess);}
void processDone(
const Status& status,
ChannelProcess::shared_pointer const & channelProcess)
{easyProcess->processDone(status,channelProcess);}
{pvaClientProcess->processDone(status,channelProcess);}
};
EasyProcess::EasyProcess(
EasyPVAPtr const &pva,
EasyChannelPtr const & easyChannel,
PvaClientProcess::PvaClientProcess(
PvaClientPtr const &pvaClient,
PvaClientChannelPtr const & pvaClientChannel,
Channel::shared_pointer const & channel,
PVStructurePtr const &pvRequest)
: easyPVA(pva),
easyChannel(easyChannel),
: pvaClient(pvaClient),
pvaClientChannel(pvaClientChannel),
channel(channel),
pvRequest(pvRequest),
isDestroyed(false),
@@ -57,57 +57,57 @@ EasyProcess::EasyProcess(
{
}
EasyProcess::~EasyProcess()
PvaClientProcess::~PvaClientProcess()
{
destroy();
}
void EasyProcess::checkProcessState()
void PvaClientProcess::checkProcessState()
{
if(isDestroyed) throw std::runtime_error("easyProcess was destroyed");
if(isDestroyed) throw std::runtime_error("pvaClientProcess was destroyed");
if(connectState==connectIdle) connect();
if(processState==processIdle) process();
}
// from ChannelProcessRequester
string EasyProcess::getRequesterName()
string PvaClientProcess::getRequesterName()
{
EasyPVAPtr yyy = easyPVA.lock();
if(!yyy) throw std::runtime_error("easyPVA was destroyed");
PvaClientPtr yyy = pvaClient.lock();
if(!yyy) throw std::runtime_error("pvaClient was destroyed");
return yyy->getRequesterName();
}
void EasyProcess::message(string const & message,MessageType messageType)
void PvaClientProcess::message(string const & message,MessageType messageType)
{
if(isDestroyed) throw std::runtime_error("easyProcess was destroyed");
EasyPVAPtr yyy = easyPVA.lock();
if(!yyy) throw std::runtime_error("easyPVA was destroyed");
if(isDestroyed) throw std::runtime_error("pvaClientProcess was destroyed");
PvaClientPtr yyy = pvaClient.lock();
if(!yyy) throw std::runtime_error("pvaClient was destroyed");
yyy->message(message, messageType);
}
void EasyProcess::channelProcessConnect(
void PvaClientProcess::channelProcessConnect(
const Status& status,
ChannelProcess::shared_pointer const & channelProcess)
{
if(isDestroyed) throw std::runtime_error("easyProcess was destroyed");
if(isDestroyed) throw std::runtime_error("pvaClientProcess was destroyed");
channelProcessConnectStatus = status;
this->channelProcess = channelProcess;
waitForConnect.signal();
}
void EasyProcess::processDone(
void PvaClientProcess::processDone(
const Status& status,
ChannelProcess::shared_pointer const & channelProcess)
{
if(isDestroyed) throw std::runtime_error("easyProcess was destroyed");
if(isDestroyed) throw std::runtime_error("pvaClientProcess was destroyed");
channelProcessStatus = status;
waitForProcess.signal();
}
// from EasyProcess
void EasyProcess::destroy()
// from PvaClientProcess
void PvaClientProcess::destroy()
{
{
Lock xx(mutex);
@@ -118,23 +118,23 @@ void EasyProcess::destroy()
channelProcess.reset();
}
void EasyProcess::connect()
void PvaClientProcess::connect()
{
if(isDestroyed) throw std::runtime_error("easyProcess was destroyed");
if(isDestroyed) throw std::runtime_error("pvaClientProcess was destroyed");
issueConnect();
Status status = waitConnect();
if(status.isOK()) return;
stringstream ss;
ss << "channel " << channel->getChannelName() << " EasyProcess::connect " << status.getMessage();
ss << "channel " << channel->getChannelName() << " PvaClientProcess::connect " << status.getMessage();
throw std::runtime_error(ss.str());
}
void EasyProcess::issueConnect()
void PvaClientProcess::issueConnect()
{
if(isDestroyed) throw std::runtime_error("easyProcess was destroyed");
if(isDestroyed) throw std::runtime_error("pvaClientProcess was destroyed");
if(connectState!=connectIdle) {
stringstream ss;
ss << "channel " << channel->getChannelName() << " easyProcess already connected ";
ss << "channel " << channel->getChannelName() << " pvaClientProcess already connected ";
throw std::runtime_error(ss.str());
}
processRequester = ChannelProcessRequester::shared_pointer(new ChannelProcessRequesterImpl(this));
@@ -142,12 +142,12 @@ void EasyProcess::issueConnect()
channelProcess = channel->createChannelProcess(processRequester,pvRequest);
}
Status EasyProcess::waitConnect()
Status PvaClientProcess::waitConnect()
{
if(isDestroyed) throw std::runtime_error("easyProcess was destroyed");
if(isDestroyed) throw std::runtime_error("pvaClientProcess was destroyed");
if(connectState!=connectActive) {
stringstream ss;
ss << "channel " << channel->getChannelName() << " easyProcess illegal connect state ";
ss << "channel " << channel->getChannelName() << " pvaClientProcess illegal connect state ";
throw std::runtime_error(ss.str());
}
waitForConnect.wait();
@@ -159,36 +159,36 @@ Status EasyProcess::waitConnect()
return Status(Status::STATUSTYPE_ERROR,channelProcessConnectStatus.getMessage());
}
void EasyProcess::process()
void PvaClientProcess::process()
{
if(isDestroyed) throw std::runtime_error("easyProcess was destroyed");
if(isDestroyed) throw std::runtime_error("pvaClientProcess was destroyed");
issueProcess();
Status status = waitProcess();
if(status.isOK()) return;
stringstream ss;
ss << "channel " << channel->getChannelName() << " EasyProcess::process " << status.getMessage();
ss << "channel " << channel->getChannelName() << " PvaClientProcess::process " << status.getMessage();
throw std::runtime_error(ss.str());
}
void EasyProcess::issueProcess()
void PvaClientProcess::issueProcess()
{
if(isDestroyed) throw std::runtime_error("easyProcess was destroyed");
if(isDestroyed) throw std::runtime_error("pvaClientProcess was destroyed");
if(connectState==connectIdle) connect();
if(processState!=processIdle) {
stringstream ss;
ss << "channel " << channel->getChannelName() << " EasyProcess::issueProcess process aleady active ";
ss << "channel " << channel->getChannelName() << " PvaClientProcess::issueProcess process aleady active ";
throw std::runtime_error(ss.str());
}
processState = processActive;
channelProcess->process();
}
Status EasyProcess::waitProcess()
Status PvaClientProcess::waitProcess()
{
if(isDestroyed) throw std::runtime_error("easyProcess was destroyed");
if(isDestroyed) throw std::runtime_error("pvaClientProcess was destroyed");
if(processState!=processActive){
stringstream ss;
ss << "channel " << channel->getChannelName() << " EasyProcess::waitProcess llegal process state";
ss << "channel " << channel->getChannelName() << " PvaClientProcess::waitProcess llegal process state";
throw std::runtime_error(ss.str());
}
waitForProcess.wait();
@@ -199,13 +199,13 @@ Status EasyProcess::waitProcess()
return Status(Status::STATUSTYPE_ERROR,channelProcessStatus.getMessage());
}
EasyProcessPtr EasyProcess::create(
EasyPVAPtr const &pva,
EasyChannelPtr const & easyChannel,
PvaClientProcessPtr PvaClientProcess::create(
PvaClientPtr const &pvaClient,
PvaClientChannelPtr const & pvaClientChannel,
Channel::shared_pointer const & channel,
PVStructurePtr const &pvRequest)
{
EasyProcessPtr epv(new EasyProcess(pva,easyChannel,channel,pvRequest));
PvaClientProcessPtr epv(new PvaClientProcess(pvaClient,pvaClientChannel,channel,pvRequest));
return epv;
}

148
src/easyPut.cpp → src/pvaClientPut.cpp
View File

@@ -1,4 +1,4 @@
/* easyPut.cpp */
/* pvaClientPut.cpp */
/**
* Copyright - See the COPYRIGHT that is included with this distribution.
* EPICS pvData is distributed subject to a Software License Agreement found
@@ -12,49 +12,49 @@
#include <sstream>
#include <pv/event.h>
#include <pv/easyPVA.h>
#include <pv/pvaClient.h>
using std::tr1::static_pointer_cast;
using namespace epics::pvData;
using namespace epics::pvAccess;
using namespace std;
namespace epics { namespace easyPVA {
namespace epics { namespace pvaClient {
class ChannelPutRequesterImpl : public ChannelPutRequester
{
EasyPut * easyPut;
PvaClientPut * pvaClientPut;
public:
ChannelPutRequesterImpl(EasyPut * easyPut)
: easyPut(easyPut) {}
ChannelPutRequesterImpl(PvaClientPut * pvaClientPut)
: pvaClientPut(pvaClientPut) {}
string getRequesterName()
{return easyPut->getRequesterName();}
{return pvaClientPut->getRequesterName();}
void message(string const & message,MessageType messageType)
{easyPut->message(message,messageType);}
{pvaClientPut->message(message,messageType);}
void channelPutConnect(
const Status& status,
ChannelPut::shared_pointer const & channelPut,
StructureConstPtr const & structure)
{easyPut->channelPutConnect(status,channelPut,structure);}
{pvaClientPut->channelPutConnect(status,channelPut,structure);}
void getDone(
const Status& status,
ChannelPut::shared_pointer const & channelPut,
PVStructurePtr const & pvStructure,
BitSetPtr const & bitSet)
{easyPut->getDone(status,channelPut,pvStructure,bitSet);}
{pvaClientPut->getDone(status,channelPut,pvStructure,bitSet);}
void putDone(
const Status& status,
ChannelPut::shared_pointer const & channelPut)
{easyPut->putDone(status,channelPut);}
{pvaClientPut->putDone(status,channelPut);}
};
EasyPut::EasyPut(
EasyPVAPtr const &pva,
EasyChannelPtr const & easyChannel,
PvaClientPut::PvaClientPut(
PvaClientPtr const &pvaClient,
PvaClientChannelPtr const & pvaClientChannel,
Channel::shared_pointer const & channel,
PVStructurePtr const &pvRequest)
: easyPVA(pva),
easyChannel(easyChannel),
: pvaClient(pvaClient),
pvaClientChannel(pvaClientChannel),
channel(channel),
pvRequest(pvRequest),
isDestroyed(false),
@@ -63,14 +63,14 @@ EasyPut::EasyPut(
{
}
EasyPut::~EasyPut()
PvaClientPut::~PvaClientPut()
{
destroy();
}
void EasyPut::checkPutState()
void PvaClientPut::checkPutState()
{
if(isDestroyed) throw std::runtime_error("easyPut was destroyed");
if(isDestroyed) throw std::runtime_error("pvaClientPut was destroyed");
if(connectState==connectIdle){
connect();
get();
@@ -78,67 +78,67 @@ void EasyPut::checkPutState()
}
// from ChannelPutRequester
string EasyPut::getRequesterName()
string PvaClientPut::getRequesterName()
{
EasyPVAPtr yyy = easyPVA.lock();
if(!yyy) throw std::runtime_error("easyPVA was destroyed");
PvaClientPtr yyy = pvaClient.lock();
if(!yyy) throw std::runtime_error("pvaClient was destroyed");
return yyy->getRequesterName();
}
void EasyPut::message(string const & message,MessageType messageType)
void PvaClientPut::message(string const & message,MessageType messageType)
{
if(isDestroyed) throw std::runtime_error("easyPut was destroyed");
EasyPVAPtr yyy = easyPVA.lock();
if(!yyy) throw std::runtime_error("easyPVA was destroyed");
if(isDestroyed) throw std::runtime_error("pvaClientPut was destroyed");
PvaClientPtr yyy = pvaClient.lock();
if(!yyy) throw std::runtime_error("pvaClient was destroyed");
yyy->message(message, messageType);
}
void EasyPut::channelPutConnect(
void PvaClientPut::channelPutConnect(
const Status& status,
ChannelPut::shared_pointer const & channelPut,
StructureConstPtr const & structure)
{
if(isDestroyed) throw std::runtime_error("easyPut was destroyed");
if(isDestroyed) throw std::runtime_error("pvaClientPut was destroyed");
channelPutConnectStatus = status;
this->channelPut = channelPut;
if(status.isOK()) {
easyData = EasyPutData::create(structure);
easyData->setMessagePrefix(easyChannel.lock()->getChannelName());
pvaClientData = PvaClientPutData::create(structure);
pvaClientData->setMessagePrefix(pvaClientChannel.lock()->getChannelName());
}
waitForConnect.signal();
}
void EasyPut::getDone(
void PvaClientPut::getDone(
const Status& status,
ChannelPut::shared_pointer const & channelPut,
PVStructurePtr const & pvStructure,
BitSetPtr const & bitSet)
{
if(isDestroyed) throw std::runtime_error("easyPut was destroyed");
if(isDestroyed) throw std::runtime_error("pvaClientPut was destroyed");
channelGetPutStatus = status;
if(status.isOK()) {
PVStructurePtr pvs = easyData->getPVStructure();
PVStructurePtr pvs = pvaClientData->getPVStructure();
pvs->copyUnchecked(*pvStructure,*bitSet);
BitSetPtr bs = easyData->getBitSet();
BitSetPtr bs = pvaClientData->getBitSet();
bs->clear();
*bs |= *bitSet;
}
waitForGetPut.signal();
}
void EasyPut::putDone(
void PvaClientPut::putDone(
const Status& status,
ChannelPut::shared_pointer const & channelPut)
{
if(isDestroyed) throw std::runtime_error("easyPut was destroyed");
if(isDestroyed) throw std::runtime_error("pvaClientPut was destroyed");
channelGetPutStatus = status;
waitForGetPut.signal();
}
// from EasyPut
void EasyPut::destroy()
// from PvaClientPut
void PvaClientPut::destroy()
{
{
Lock xx(mutex);
@@ -149,23 +149,23 @@ void EasyPut::destroy()
channelPut.reset();
}
void EasyPut::connect()
void PvaClientPut::connect()
{
if(isDestroyed) throw std::runtime_error("easyPut was destroyed");
if(isDestroyed) throw std::runtime_error("pvaClientPut was destroyed");
issueConnect();
Status status = waitConnect();
if(status.isOK()) return;
stringstream ss;
ss << "channel " << channel->getChannelName() << " EasyPut::connect " << status.getMessage();
ss << "channel " << channel->getChannelName() << " PvaClientPut::connect " << status.getMessage();
throw std::runtime_error(ss.str());
}
void EasyPut::issueConnect()
void PvaClientPut::issueConnect()
{
if(isDestroyed) throw std::runtime_error("easyPut was destroyed");
if(isDestroyed) throw std::runtime_error("pvaClientPut was destroyed");
if(connectState!=connectIdle) {
stringstream ss;
ss << "channel " << channel->getChannelName() << " easyPut already connected ";
ss << "channel " << channel->getChannelName() << " pvaClientPut already connected ";
throw std::runtime_error(ss.str());
}
putRequester = ChannelPutRequester::shared_pointer(new ChannelPutRequesterImpl(this));
@@ -173,12 +173,12 @@ void EasyPut::issueConnect()
channelPut = channel->createChannelPut(putRequester,pvRequest);
}
Status EasyPut::waitConnect()
Status PvaClientPut::waitConnect()
{
if(isDestroyed) throw std::runtime_error("easyPut was destroyed");
if(isDestroyed) throw std::runtime_error("pvaClientPut was destroyed");
if(connectState!=connectActive) {
stringstream ss;
ss << "channel " << channel->getChannelName() << " easyPut illegal connect state ";
ss << "channel " << channel->getChannelName() << " pvaClientPut illegal connect state ";
throw std::runtime_error(ss.str());
}
waitForConnect.wait();
@@ -190,37 +190,37 @@ Status EasyPut::waitConnect()
return Status(Status::STATUSTYPE_ERROR,channelPutConnectStatus.getMessage());
}
void EasyPut::get()
void PvaClientPut::get()
{
if(isDestroyed) throw std::runtime_error("easyPut was destroyed");
if(isDestroyed) throw std::runtime_error("pvaClientPut was destroyed");
issueGet();
Status status = waitGet();
if(status.isOK()) return;
stringstream ss;
ss << "channel " << channel->getChannelName() << " EasyPut::get " << status.getMessage();
ss << "channel " << channel->getChannelName() << " PvaClientPut::get " << status.getMessage();
throw std::runtime_error(ss.str());
}
void EasyPut::issueGet()
void PvaClientPut::issueGet()
{
if(isDestroyed) throw std::runtime_error("easyPut was destroyed");
if(isDestroyed) throw std::runtime_error("pvaClientPut was destroyed");
if(connectState==connectIdle) connect();
if(putState!=putIdle) {
stringstream ss;
ss << "channel " << channel->getChannelName() << " EasyPut::issueGet get or put aleady active ";
ss << "channel " << channel->getChannelName() << " PvaClientPut::issueGet get or put aleady active ";
throw std::runtime_error(ss.str());
}
putState = getActive;
easyData->getBitSet()->clear();
pvaClientData->getBitSet()->clear();
channelPut->get();
}
Status EasyPut::waitGet()
Status PvaClientPut::waitGet()
{
if(isDestroyed) throw std::runtime_error("easyPut was destroyed");
if(isDestroyed) throw std::runtime_error("pvaClientPut was destroyed");
if(putState!=getActive){
stringstream ss;
ss << "channel " << channel->getChannelName() << " EasyPut::waitGet llegal put state";
ss << "channel " << channel->getChannelName() << " PvaClientPut::waitGet llegal put state";
throw std::runtime_error(ss.str());
}
waitForGetPut.wait();
@@ -231,60 +231,60 @@ Status EasyPut::waitGet()
return Status(Status::STATUSTYPE_ERROR,channelGetPutStatus.getMessage());
}
void EasyPut::put()
void PvaClientPut::put()
{
if(isDestroyed) throw std::runtime_error("easyPut was destroyed");
if(isDestroyed) throw std::runtime_error("pvaClientPut was destroyed");
issuePut();
Status status = waitPut();
if(status.isOK()) return;
stringstream ss;
ss << "channel " << channel->getChannelName() << " EasyPut::put " << status.getMessage();
ss << "channel " << channel->getChannelName() << " PvaClientPut::put " << status.getMessage();
throw std::runtime_error(ss.str());
}
void EasyPut::issuePut()
void PvaClientPut::issuePut()
{
if(isDestroyed) throw std::runtime_error("easyPut was destroyed");
if(isDestroyed) throw std::runtime_error("pvaClientPut was destroyed");
if(connectState==connectIdle) connect();
if(putState!=putIdle) {
stringstream ss;
ss << "channel " << channel->getChannelName() << " EasyPut::issueGet get or put aleady active ";
ss << "channel " << channel->getChannelName() << " PvaClientPut::issueGet get or put aleady active ";
throw std::runtime_error(ss.str());
}
putState = putActive;
channelPut->put(easyData->getPVStructure(),easyData->getBitSet());
channelPut->put(pvaClientData->getPVStructure(),pvaClientData->getBitSet());
}
Status EasyPut::waitPut()
Status PvaClientPut::waitPut()
{
if(isDestroyed) throw std::runtime_error("easyPut was destroyed");
if(isDestroyed) throw std::runtime_error("pvaClientPut was destroyed");
if(putState!=putActive){
stringstream ss;
ss << "channel " << channel->getChannelName() << " EasyPut::waitPut llegal put state";
ss << "channel " << channel->getChannelName() << " PvaClientPut::waitPut llegal put state";
throw std::runtime_error(ss.str());
}
waitForGetPut.wait();
putState = putIdle;
if(channelGetPutStatus.isOK()) {
easyData->getBitSet()->clear();
pvaClientData->getBitSet()->clear();
return Status::Ok;
}
return Status(Status::STATUSTYPE_ERROR,channelGetPutStatus.getMessage());
}
EasyPutDataPtr EasyPut::getData()
PvaClientPutDataPtr PvaClientPut::getData()
{
checkPutState();
return easyData;
return pvaClientData;
}
EasyPutPtr EasyPut::create(
EasyPVAPtr const &pva,
EasyChannelPtr const & easyChannel,
PvaClientPutPtr PvaClientPut::create(
PvaClientPtr const &pvaClient,
PvaClientChannelPtr const & pvaClientChannel,
Channel::shared_pointer const & channel,
PVStructurePtr const &pvRequest)
{
EasyPutPtr epv(new EasyPut(pva,easyChannel,channel,pvRequest));
PvaClientPutPtr epv(new PvaClientPut(pvaClient,pvaClientChannel,channel,pvRequest));
return epv;
}

67
src/easyPutData.cpp → src/pvaClientPutData.cpp
View File

@@ -1,4 +1,4 @@
/* easyPutData.cpp */
/* pvaClientPutData.cpp */
/**
* Copyright - See the COPYRIGHT that is included with this distribution.
* EPICS pvData is distributed subject to a Software License Agreement found
@@ -13,7 +13,7 @@
#include <typeinfo>
#include <sstream>
#include <pv/easyPVA.h>
#include <pv/pvaClient.h>
#include <pv/createRequest.h>
#include <pv/convert.h>
@@ -23,14 +23,14 @@ using namespace epics::pvData;
using namespace epics::pvAccess;
using namespace std;
namespace epics { namespace easyPVA {
namespace epics { namespace pvaClient {
class EasyPostHandlerPvt: public PostHandler
class PvaClientPostHandlerPvt: public PostHandler
{
EasyPutData * easyData;
PvaClientPutData * easyData;
size_t fieldNumber;
public:
EasyPostHandlerPvt(EasyPutData *easyData,size_t fieldNumber)
PvaClientPostHandlerPvt(PvaClientPutData *easyData,size_t fieldNumber)
: easyData(easyData),fieldNumber(fieldNumber){}
void postPut() { easyData->postPut(fieldNumber);}
};
@@ -46,13 +46,13 @@ static string notScalarArray("value is not a scalarArray");
static string notDoubleArray("value is not a doubleArray");
static string notStringArray("value is not a stringArray");
EasyPutDataPtr EasyPutData::create(StructureConstPtr const & structure)
PvaClientPutDataPtr PvaClientPutData::create(StructureConstPtr const & structure)
{
EasyPutDataPtr epv(new EasyPutData(structure));
PvaClientPutDataPtr epv(new PvaClientPutData(structure));
return epv;
}
EasyPutData::EasyPutData(StructureConstPtr const & structure)
PvaClientPutData::PvaClientPutData(StructureConstPtr const & structure)
: structure(structure),
pvStructure(getPVDataCreate()->createPVStructure(structure)),
bitSet(BitSetPtr(new BitSet(pvStructure->getNumberFields())))
@@ -62,7 +62,7 @@ EasyPutData::EasyPutData(StructureConstPtr const & structure)
PVFieldPtr pvField;
for(size_t i =0; i<nfields; ++i)
{
postHandler[i] = PostHandlerPtr(new EasyPostHandlerPvt(this, i));
postHandler[i] = PostHandlerPtr(new PvaClientPostHandlerPvt(this, i));
if(i==0) {
pvField = pvStructure;
} else {
@@ -73,32 +73,32 @@ EasyPutData::EasyPutData(StructureConstPtr const & structure)
pvValue = pvStructure->getSubField("value");
}
void EasyPutData::checkValue()
void PvaClientPutData::checkValue()
{
if(pvValue) return;
throw std::runtime_error(messagePrefix + noValue);
}
void EasyPutData::postPut(size_t fieldNumber)
void PvaClientPutData::postPut(size_t fieldNumber)
{
bitSet->set(fieldNumber);
}
void EasyPutData::setMessagePrefix(std::string const & value)
void PvaClientPutData::setMessagePrefix(std::string const & value)
{
messagePrefix = value + " ";
}
StructureConstPtr EasyPutData::getStructure()
StructureConstPtr PvaClientPutData::getStructure()
{return structure;}
PVStructurePtr EasyPutData::getPVStructure()
PVStructurePtr PvaClientPutData::getPVStructure()
{return pvStructure;}
BitSetPtr EasyPutData::getBitSet()
BitSetPtr PvaClientPutData::getBitSet()
{return bitSet;}
std::ostream & EasyPutData::showChanged(std::ostream & out)
std::ostream & PvaClientPutData::showChanged(std::ostream & out)
{
size_t nextSet = bitSet->nextSetBit(0);
PVFieldPtr pvField;
@@ -115,33 +115,33 @@ std::ostream & EasyPutData::showChanged(std::ostream & out)
return out;
}
bool EasyPutData::hasValue()
bool PvaClientPutData::hasValue()
{
if(!pvValue) return false;
return true;
}
bool EasyPutData::isValueScalar()
bool PvaClientPutData::isValueScalar()
{
if(!pvValue) return false;
if(pvValue->getField()->getType()==scalar) return true;
return false;
}
bool EasyPutData::isValueScalarArray()
bool PvaClientPutData::isValueScalarArray()
{
if(!pvValue) return false;
if(pvValue->getField()->getType()==scalarArray) return true;
return false;
}
PVFieldPtr EasyPutData::getValue()
PVFieldPtr PvaClientPutData::getValue()
{
checkValue();
return pvValue;
}
PVScalarPtr EasyPutData::getScalarValue()
PVScalarPtr PvaClientPutData::getScalarValue()
{
checkValue();
PVScalarPtr pv = pvStructure->getSubField<PVScalar>("value");
@@ -151,7 +151,7 @@ PVScalarPtr EasyPutData::getScalarValue()
return pv;
}
PVArrayPtr EasyPutData::getArrayValue()
PVArrayPtr PvaClientPutData::getArrayValue()
{
checkValue();
PVArrayPtr pv = pvStructure->getSubField<PVArray>("value");
@@ -161,7 +161,7 @@ PVArrayPtr EasyPutData::getArrayValue()
return pv;
}
PVScalarArrayPtr EasyPutData::getScalarArrayValue()
PVScalarArrayPtr PvaClientPutData::getScalarArrayValue()
{
checkValue();
PVScalarArrayPtr pv = pvStructure->getSubField<PVScalarArray>("value");
@@ -171,7 +171,7 @@ PVScalarArrayPtr EasyPutData::getScalarArrayValue()
return pv;
}
double EasyPutData::getDouble()
double PvaClientPutData::getDouble()
{
PVScalarPtr pvScalar = getScalarValue();
ScalarType scalarType = pvScalar->getScalar()->getScalarType();
@@ -185,13 +185,13 @@ double EasyPutData::getDouble()
return convert->toDouble(pvScalar);
}
string EasyPutData::getString()
string PvaClientPutData::getString()
{
PVScalarPtr pvScalar = getScalarValue();
return convert->toString(pvScalar);
}
shared_vector<const double> EasyPutData::getDoubleArray()
shared_vector<const double> PvaClientPutData::getDoubleArray()
{
checkValue();
PVDoubleArrayPtr pv = pvStructure->getSubField<PVDoubleArray>("value");
@@ -201,7 +201,7 @@ shared_vector<const double> EasyPutData::getDoubleArray()
return pv->view();
}
shared_vector<const string> EasyPutData::getStringArray()
shared_vector<const string> PvaClientPutData::getStringArray()
{
checkValue();
PVStringArrayPtr pv = pvStructure->getSubField<PVStringArray>("value");
@@ -212,13 +212,14 @@ shared_vector<const string> EasyPutData::getStringArray()
}
void EasyPutData::putDouble(double value)
void PvaClientPutData::putDouble(double value)
{
PVScalarPtr pvScalar = getScalarValue();
ScalarType scalarType = pvScalar->getScalar()->getScalarType();
if(scalarType==pvDouble) {
PVDoublePtr pvDouble = static_pointer_cast<PVDouble>(pvScalar);
pvDouble->put(value);
return;
}
if(!ScalarTypeFunc::isNumeric(scalarType)) {
throw std::runtime_error(messagePrefix + notCompatibleScalar);
@@ -226,7 +227,7 @@ void EasyPutData::putDouble(double value)
convert->fromDouble(pvScalar,value);
}
void EasyPutData::putString(std::string const & value)
void PvaClientPutData::putString(std::string const & value)
{
PVScalarPtr pvScalar = getScalarValue();
convert->fromString(pvScalar,value);
@@ -234,7 +235,7 @@ void EasyPutData::putString(std::string const & value)
void EasyPutData::putDoubleArray(shared_vector<const double> const & value)
void PvaClientPutData::putDoubleArray(shared_vector<const double> const & value)
{
checkValue();
PVDoubleArrayPtr pv = pvStructure->getSubField<PVDoubleArray>("value");
@@ -244,7 +245,7 @@ void EasyPutData::putDoubleArray(shared_vector<const double> const & value)
pv->replace(value);
}
void EasyPutData::putStringArray(shared_vector<const std::string> const & value)
void PvaClientPutData::putStringArray(shared_vector<const std::string> const & value)
{
checkValue();
PVStringArrayPtr pv = pvStructure->getSubField<PVStringArray>("value");
@@ -254,7 +255,7 @@ void EasyPutData::putStringArray(shared_vector<const std::string> const & value)
pv->replace(value);
}
void EasyPutData::putStringArray(std::vector<std::string> const & value)
void PvaClientPutData::putStringArray(std::vector<std::string> const & value)
{
checkValue();
PVScalarArrayPtr pv = pvStructure->getSubField<PVScalarArray>("value");

180
src/easyPutGet.cpp → src/pvaClientPutGet.cpp
View File

@@ -1,4 +1,4 @@
/* easyPutGet.cpp */
/* pvaClientPutGet.cpp */
/**
* Copyright - See the COPYRIGHT that is included with this distribution.
* EPICS pvData is distributed subject to a Software License Agreement found
@@ -12,32 +12,32 @@
#include <sstream>
#include <pv/event.h>
#include <pv/easyPVA.h>
#include <pv/pvaClient.h>
using std::tr1::static_pointer_cast;
using namespace epics::pvData;
using namespace epics::pvAccess;
using namespace std;
namespace epics { namespace easyPVA {
namespace epics { namespace pvaClient {
class ChannelPutGetRequesterImpl : public ChannelPutGetRequester
{
EasyPutGet * easyPutGet;
PvaClientPutGet * pvaClientPutGet;
public:
ChannelPutGetRequesterImpl(EasyPutGet * easyPutGet)
: easyPutGet(easyPutGet) {}
ChannelPutGetRequesterImpl(PvaClientPutGet * pvaClientPutGet)
: pvaClientPutGet(pvaClientPutGet) {}
string getRequesterName()
{return easyPutGet->getRequesterName();}
{return pvaClientPutGet->getRequesterName();}
void message(string const & message,MessageType messageType)
{easyPutGet->message(message,messageType);}
{pvaClientPutGet->message(message,messageType);}
void channelPutGetConnect(
const epics::pvData::Status& status,
epics::pvAccess::ChannelPutGet::shared_pointer const & channelPutGet,
epics::pvData::StructureConstPtr const & putStructure,
epics::pvData::StructureConstPtr const & getStructure)
{
easyPutGet->channelPutGetConnect(status,channelPutGet,putStructure,getStructure);
pvaClientPutGet->channelPutGetConnect(status,channelPutGet,putStructure,getStructure);
}
void putGetDone(
const epics::pvData::Status& status,
@@ -45,7 +45,7 @@ public:
epics::pvData::PVStructurePtr const & getPVStructure,
epics::pvData::BitSetPtr const & getBitSet)
{
easyPutGet->putGetDone(status,channelPutGet,getPVStructure,getBitSet);
pvaClientPutGet->putGetDone(status,channelPutGet,getPVStructure,getBitSet);
}
void getPutDone(
const epics::pvData::Status& status,
@@ -53,7 +53,7 @@ public:
epics::pvData::PVStructurePtr const & putPVStructure,
epics::pvData::BitSet::shared_pointer const & putBitSet)
{
easyPutGet->getPutDone(status,channelPutGet,putPVStructure,putBitSet);
pvaClientPutGet->getPutDone(status,channelPutGet,putPVStructure,putBitSet);
}
void getGetDone(
const epics::pvData::Status& status,
@@ -61,17 +61,17 @@ public:
epics::pvData::PVStructurePtr const & getPVStructure,
epics::pvData::BitSet::shared_pointer const & getBitSet)
{
easyPutGet->getGetDone(status,channelPutGet,getPVStructure,getBitSet);
pvaClientPutGet->getGetDone(status,channelPutGet,getPVStructure,getBitSet);
}
};
EasyPutGet::EasyPutGet(
EasyPVAPtr const &pva,
EasyChannelPtr const & easyChannel,
PvaClientPutGet::PvaClientPutGet(
PvaClientPtr const &pvaClient,
PvaClientChannelPtr const & pvaClientChannel,
Channel::shared_pointer const & channel,
PVStructurePtr const &pvRequest)
: easyPVA(pva),
easyChannel(easyChannel),
: pvaClient(pvaClient),
pvaClientChannel(pvaClientChannel),
channel(channel),
pvRequest(pvRequest),
isDestroyed(false),
@@ -80,14 +80,14 @@ EasyPutGet::EasyPutGet(
{
}
EasyPutGet::~EasyPutGet()
PvaClientPutGet::~PvaClientPutGet()
{
destroy();
}
void EasyPutGet::checkPutGetState()
void PvaClientPutGet::checkPutGetState()
{
if(isDestroyed) throw std::runtime_error("easyPutGet was destroyed");
if(isDestroyed) throw std::runtime_error("pvaClientPutGet was destroyed");
if(connectState==connectIdle){
connect();
getPut();
@@ -95,90 +95,90 @@ void EasyPutGet::checkPutGetState()
}
// from ChannelPutGetRequester
string EasyPutGet::getRequesterName()
string PvaClientPutGet::getRequesterName()
{
EasyPVAPtr yyy = easyPVA.lock();
if(!yyy) throw std::runtime_error("easyPVA was destroyed");
PvaClientPtr yyy = pvaClient.lock();
if(!yyy) throw std::runtime_error("pvaClient was destroyed");
return yyy->getRequesterName();
}
void EasyPutGet::message(string const & message,MessageType messageType)
void PvaClientPutGet::message(string const & message,MessageType messageType)
{
if(isDestroyed) throw std::runtime_error("easyPutGet was destroyed");
EasyPVAPtr yyy = easyPVA.lock();
if(!yyy) throw std::runtime_error("easyPVA was destroyed");
if(isDestroyed) throw std::runtime_error("pvaClientPutGet was destroyed");
PvaClientPtr yyy = pvaClient.lock();
if(!yyy) throw std::runtime_error("pvaClient was destroyed");
yyy->message(message, messageType);
}
void EasyPutGet::channelPutGetConnect(
void PvaClientPutGet::channelPutGetConnect(
const Status& status,
ChannelPutGet::shared_pointer const & channelPutGet,
StructureConstPtr const & putStructure,
StructureConstPtr const & getStructure)
{
if(isDestroyed) throw std::runtime_error("easyPutGet was destroyed");
if(isDestroyed) throw std::runtime_error("pvaClientPutGet was destroyed");
channelPutGetConnectStatus = status;
this->channelPutGet = channelPutGet;
if(status.isOK()) {
easyPutData = EasyPutData::create(putStructure);
easyPutData->setMessagePrefix(easyChannel.lock()->getChannelName());
easyGetData = EasyGetData::create(getStructure);
easyGetData->setMessagePrefix(easyChannel.lock()->getChannelName());
pvaClientPutData = PvaClientPutData::create(putStructure);
pvaClientPutData->setMessagePrefix(pvaClientChannel.lock()->getChannelName());
pvaClientGetData = PvaClientGetData::create(getStructure);
pvaClientGetData->setMessagePrefix(pvaClientChannel.lock()->getChannelName());
}
waitForConnect.signal();
}
void EasyPutGet::putGetDone(
void PvaClientPutGet::putGetDone(
const Status& status,
ChannelPutGet::shared_pointer const & channelPutGet,
PVStructurePtr const & getPVStructure,
BitSetPtr const & getBitSet)
{
if(isDestroyed) throw std::runtime_error("easyPutGet was destroyed");
if(isDestroyed) throw std::runtime_error("pvaClientPutGet was destroyed");
channelPutGetStatus = status;
if(status.isOK()) {
easyGetData->setData(getPVStructure,getBitSet);
pvaClientGetData->setData(getPVStructure,getBitSet);
}
waitForPutGet.signal();
}
void EasyPutGet::getPutDone(
void PvaClientPutGet::getPutDone(
const Status& status,
ChannelPutGet::shared_pointer const & channelPutGet,
PVStructurePtr const & putPVStructure,
BitSetPtr const & putBitSet)
{
if(isDestroyed) throw std::runtime_error("easyPutGet was destroyed");
if(isDestroyed) throw std::runtime_error("pvaClientPutGet was destroyed");
channelGetPutGetStatus = status;
if(status.isOK()) {
PVStructurePtr pvs = easyPutData->getPVStructure();
PVStructurePtr pvs = pvaClientPutData->getPVStructure();
pvs->copyUnchecked(*putPVStructure,*putBitSet);
BitSetPtr bs = easyPutData->getBitSet();
BitSetPtr bs = pvaClientPutData->getBitSet();
bs->clear();
*bs |= *putBitSet;
}
waitForPutGet.signal();
}
void EasyPutGet::getGetDone(
void PvaClientPutGet::getGetDone(
const Status& status,
ChannelPutGet::shared_pointer const & channelPutGet,
PVStructurePtr const & getPVStructure,
BitSetPtr const & getBitSet)
{
if(isDestroyed) throw std::runtime_error("easyPutGet was destroyed");
if(isDestroyed) throw std::runtime_error("pvaClientPutGet was destroyed");
channelPutGetStatus = status;
if(status.isOK()) {
easyGetData->setData(getPVStructure,getBitSet);
pvaClientGetData->setData(getPVStructure,getBitSet);
}
waitForPutGet.signal();
}
// from EasyPutGet
void EasyPutGet::destroy()
// from PvaClientPutGet
void PvaClientPutGet::destroy()
{
{
Lock xx(mutex);
@@ -189,23 +189,23 @@ void EasyPutGet::destroy()
channelPutGet.reset();
}
void EasyPutGet::connect()
void PvaClientPutGet::connect()
{
if(isDestroyed) throw std::runtime_error("easyPutGet was destroyed");
if(isDestroyed) throw std::runtime_error("pvaClientPutGet was destroyed");
issueConnect();
Status status = waitConnect();
if(status.isOK()) return;
stringstream ss;
ss << "channel " << channel->getChannelName() << " EasyPutGet::connect " << status.getMessage();
ss << "channel " << channel->getChannelName() << " PvaClientPutGet::connect " << status.getMessage();
throw std::runtime_error(ss.str());
}
void EasyPutGet::issueConnect()
void PvaClientPutGet::issueConnect()
{
if(isDestroyed) throw std::runtime_error("easyPutGet was destroyed");
if(isDestroyed) throw std::runtime_error("pvaClientPutGet was destroyed");
if(connectState!=connectIdle) {
stringstream ss;
ss << "channel " << channel->getChannelName() << " easyPutGet already connected ";
ss << "channel " << channel->getChannelName() << " pvaClientPutGet already connected ";
throw std::runtime_error(ss.str());
}
putGetRequester = ChannelPutGetRequester::shared_pointer(new ChannelPutGetRequesterImpl(this));
@@ -213,12 +213,12 @@ void EasyPutGet::issueConnect()
channelPutGet = channel->createChannelPutGet(putGetRequester,pvRequest);
}
Status EasyPutGet::waitConnect()
Status PvaClientPutGet::waitConnect()
{
if(isDestroyed) throw std::runtime_error("easyPutGet was destroyed");
if(isDestroyed) throw std::runtime_error("pvaClientPutGet was destroyed");
if(connectState!=connectActive) {
stringstream ss;
ss << "channel " << channel->getChannelName() << " easyPutGet illegal connect state ";
ss << "channel " << channel->getChannelName() << " pvaClientPutGet illegal connect state ";
throw std::runtime_error(ss.str());
}
waitForConnect.wait();
@@ -231,37 +231,37 @@ Status EasyPutGet::waitConnect()
}
void EasyPutGet::putGet()
void PvaClientPutGet::putGet()
{
if(isDestroyed) throw std::runtime_error("easyPutGet was destroyed");
if(isDestroyed) throw std::runtime_error("pvaClientPutGet was destroyed");
issuePutGet();
Status status = waitPutGet();
if(status.isOK()) return;
stringstream ss;
ss << "channel " << channel->getChannelName() << " EasyPutGet::putGet " << status.getMessage();
ss << "channel " << channel->getChannelName() << " PvaClientPutGet::putGet " << status.getMessage();
throw std::runtime_error(ss.str());
}
void EasyPutGet::issuePutGet()
void PvaClientPutGet::issuePutGet()
{
if(isDestroyed) throw std::runtime_error("easyPutGet was destroyed");
if(isDestroyed) throw std::runtime_error("pvaClientPutGet was destroyed");
if(connectState==connectIdle) connect();
if(putGetState!=putGetIdle) {
stringstream ss;
ss << "channel " << channel->getChannelName() << " EasyPutGet::issueGet get or put aleady active ";
ss << "channel " << channel->getChannelName() << " PvaClientPutGet::issueGet get or put aleady active ";
throw std::runtime_error(ss.str());
}
putGetState = putGetActive;
channelPutGet->putGet(easyPutData->getPVStructure(),easyPutData->getBitSet());
channelPutGet->putGet(pvaClientPutData->getPVStructure(),pvaClientPutData->getBitSet());
}
Status EasyPutGet::waitPutGet()
Status PvaClientPutGet::waitPutGet()
{
if(isDestroyed) throw std::runtime_error("easyPutGet was destroyed");
if(isDestroyed) throw std::runtime_error("pvaClientPutGet was destroyed");
if(putGetState!=putGetActive){
stringstream ss;
ss << "channel " << channel->getChannelName() << " EasyPutGet::waitPutGet llegal put state";
ss << "channel " << channel->getChannelName() << " PvaClientPutGet::waitPutGet llegal put state";
throw std::runtime_error(ss.str());
}
waitForPutGet.wait();
@@ -272,36 +272,36 @@ Status EasyPutGet::waitPutGet()
return Status(Status::STATUSTYPE_ERROR,channelGetPutGetStatus.getMessage());
}
void EasyPutGet::getGet()
void PvaClientPutGet::getGet()
{
if(isDestroyed) throw std::runtime_error("easyPutGet was destroyed");
if(isDestroyed) throw std::runtime_error("pvaClientPutGet was destroyed");
issueGetGet();
Status status = waitGetGet();
if(status.isOK()) return;
stringstream ss;
ss << "channel " << channel->getChannelName() << " EasyPutGet::getGet " << status.getMessage();
ss << "channel " << channel->getChannelName() << " PvaClientPutGet::getGet " << status.getMessage();
throw std::runtime_error(ss.str());
}
void EasyPutGet::issueGetGet()
void PvaClientPutGet::issueGetGet()
{
if(isDestroyed) throw std::runtime_error("easyPutGet was destroyed");
if(isDestroyed) throw std::runtime_error("pvaClientPutGet was destroyed");
if(connectState==connectIdle) connect();
if(putGetState!=putGetIdle) {
stringstream ss;
ss << "channel " << channel->getChannelName() << " EasyPutGet::issueGetGet aleady active ";
ss << "channel " << channel->getChannelName() << " PvaClientPutGet::issueGetGet aleady active ";
throw std::runtime_error(ss.str());
}
putGetState = putGetActive;
channelPutGet->getGet();
}
Status EasyPutGet::waitGetGet()
Status PvaClientPutGet::waitGetGet()
{
if(isDestroyed) throw std::runtime_error("easyPutGet was destroyed");
if(isDestroyed) throw std::runtime_error("pvaClientPutGet was destroyed");
if(putGetState!=putGetActive){
stringstream ss;
ss << "channel " << channel->getChannelName() << " EasyPutGet::waitGetGet illegal state";
ss << "channel " << channel->getChannelName() << " PvaClientPutGet::waitGetGet illegal state";
throw std::runtime_error(ss.str());
}
waitForPutGet.wait();
@@ -312,36 +312,36 @@ Status EasyPutGet::waitGetGet()
return Status(Status::STATUSTYPE_ERROR,channelGetPutGetStatus.getMessage());
}
void EasyPutGet::getPut()
void PvaClientPutGet::getPut()
{
if(isDestroyed) throw std::runtime_error("easyPutGet was destroyed");
if(isDestroyed) throw std::runtime_error("pvaClientPutGet was destroyed");
issueGetPut();
Status status = waitGetPut();
if(status.isOK()) return;
stringstream ss;
ss << "channel " << channel->getChannelName() << " EasyPutGet::getPut " << status.getMessage();
ss << "channel " << channel->getChannelName() << " PvaClientPutGet::getPut " << status.getMessage();
throw std::runtime_error(ss.str());
}
void EasyPutGet::issueGetPut()
void PvaClientPutGet::issueGetPut()
{
if(isDestroyed) throw std::runtime_error("easyPutGet was destroyed");
if(isDestroyed) throw std::runtime_error("pvaClientPutGet was destroyed");
if(connectState==connectIdle) connect();
if(putGetState!=putGetIdle) {
stringstream ss;
ss << "channel " << channel->getChannelName() << " EasyPutGet::issueGetPut aleady active ";
ss << "channel " << channel->getChannelName() << " PvaClientPutGet::issueGetPut aleady active ";
throw std::runtime_error(ss.str());
}
putGetState = putGetActive;
channelPutGet->getPut();
}
Status EasyPutGet::waitGetPut()
Status PvaClientPutGet::waitGetPut()
{
if(isDestroyed) throw std::runtime_error("easyPutGet was destroyed");
if(isDestroyed) throw std::runtime_error("pvaClientPutGet was destroyed");
if(putGetState!=putGetActive){
stringstream ss;
ss << "channel " << channel->getChannelName() << " EasyPutGet::waitGetPut illegal state";
ss << "channel " << channel->getChannelName() << " PvaClientPutGet::waitGetPut illegal state";
throw std::runtime_error(ss.str());
}
waitForPutGet.wait();
@@ -352,25 +352,25 @@ Status EasyPutGet::waitGetPut()
return Status(Status::STATUSTYPE_ERROR,channelGetPutGetStatus.getMessage());
}
EasyGetDataPtr EasyPutGet::getGetData()
PvaClientGetDataPtr PvaClientPutGet::getGetData()
{
checkPutGetState();
return easyGetData;
return pvaClientGetData;
}
EasyPutDataPtr EasyPutGet::getPutData()
PvaClientPutDataPtr PvaClientPutGet::getPutData()
{
checkPutGetState();
return easyPutData;
return pvaClientPutData;
}
EasyPutGetPtr EasyPutGet::create(
EasyPVAPtr const &pva,
EasyChannelPtr const & easyChannel,
PvaClientPutGetPtr PvaClientPutGet::create(
PvaClientPtr const &pvaClient,
PvaClientChannelPtr const & pvaClientChannel,
Channel::shared_pointer const & channel,
PVStructurePtr const &pvRequest)
{
EasyPutGetPtr epv(new EasyPutGet(pva,easyChannel,channel,pvRequest));
PvaClientPutGetPtr epv(new PvaClientPutGet(pvaClient,pvaClientChannel,channel,pvRequest));
return epv;
}

64
test/src/Makefile
View File

@@ -3,54 +3,54 @@
TOP = ..
include $(TOP)/configure/CONFIG
TESTPROD_HOST += testEasyPutData
testEasyPutData_SRCS = testEasyPutData
testHarness_SRCS += testEasyPutData.cpp
TESTS += testEasyPutData
TESTPROD_HOST += pvaClientTestPutData
pvaClientTestPutData_SRCS = pvaClientTestPutData
testHarness_SRCS += pvaClientTestPutData.cpp
TESTS += pvaClientTestPutData
TESTPROD_HOST += testEasyGetData
testEasyGetData_SRCS = testEasyGetData
testHarness_SRCS += testEasyGetData.cpp
TESTS += testEasyGetData
TESTPROD_HOST += pvaClientTestGetData
pvaClientTestGetData_SRCS = pvaClientTestGetData
testHarness_SRCS += pvaClientTestGetData.cpp
TESTS += pvaClientTestGetData
TESTPROD_HOST += testEasyMonitorData
testEasyMonitorData_SRCS = testEasyMonitorData
testHarness_SRCS += testEasyMonitorData.cpp
TESTS += testEasyMonitorData
TESTPROD_HOST += pvaClientTestMonitorData
pvaClientTestMonitorData_SRCS = pvaClientTestMonitorData
testHarness_SRCS += pvaClientTestMonitorData.cpp
TESTS += pvaClientTestMonitorData
TESTPROD_HOST += testEasyPutGetMonitor
testEasyPutGetMonitor_SRCS = testEasyPutGetMonitor
testHarness_SRCS += testEasyPutGetMonitor.cpp
TESTS += testEasyPutGetMonitor
TESTPROD_HOST += pvaClientTestPutGetMonitor
pvaClientTestPutGetMonitor_SRCS = pvaClientTestPutGetMonitor
testHarness_SRCS += pvaClientTestPutGetMonitor.cpp
TESTS += pvaClientTestPutGetMonitor
TESTPROD_HOST += testEasyPutGet
testEasyPutGet_SRCS = testEasyPutGet
testHarness_SRCS += testEasyPutGet.cpp
TESTS += testEasyPutGet
TESTPROD_HOST += pvaClientTestPutGet
pvaClientTestPutGet_SRCS = pvaClientTestPutGet
testHarness_SRCS += pvaClientTestPutGet.cpp
TESTS += pvaClientTestPutGet
TESTPROD_HOST += testEasyMultiDouble
testEasyMultiDouble_SRCS = testEasyMultiDouble
testHarness_SRCS += testEasyMultiDouble.cpp
TESTS += testEasyMultiDouble
TESTPROD_HOST += pvaClientTestMultiDouble
pvaClientTestMultiDouble_SRCS = pvaClientTestMultiDouble
testHarness_SRCS += pvaClientTestMultiDouble.cpp
TESTS += pvaClientTestMultiDouble
TESTPROD_HOST += testEasyNTMultiChannel
testEasyNTMultiChannel_SRCS = testEasyNTMultiChannel
testHarness_SRCS += testEasyNTMultiChannel.cpp
TESTS += testEasyNTMultiChannel
TESTPROD_HOST += pvaClientTestNTMultiChannel
pvaClientTestNTMultiChannel_SRCS = pvaClientTestNTMultiChannel
testHarness_SRCS += pvaClientTestNTMultiChannel.cpp
TESTS += pvaClientTestNTMultiChannel
PROD_LIBS += easyPVA pvAccess pvData nt Com
PROD_LIBS += pvaClient pvAccess pvData nt Com
testHarness_SRCS += easyAllTests.c
testHarness_SRCS += pvaClientAllTests.c
PROD_vxWorks = vxTestHarness
vxTestHarness_SRCS += $(testHarness_SRCS)
TESTSPEC_vxWorks = vxTestHarness.$(MUNCH_SUFFIX); easyAllTests
TESTSPEC_vxWorks = vxTestHarness.$(MUNCH_SUFFIX); pvaClientAllTests
PROD_RTEMS += rtemsTestHarness
rtemsTestHarness_SRCS += rtemsTestHarness.c rtemsConfig.c
rtemsTestHarness_SRCS += $(testHarness_SRCS)
TESTSPEC_RTEMS = rtemsTestHarness.$(MUNCH_SUFFIX); easyAllTests
TESTSPEC_RTEMS = rtemsTestHarness.$(MUNCH_SUFFIX); pvaClientAllTests
TESTSCRIPTS_HOST += $(TESTS:%=%.t)

31
test/src/easyAllTests.c
View File

@@ -1,31 +0,0 @@
/*
* Run EasyPVA tests as a batch.
*
* Do *not* include performance measurements here, they don't help to
* prove functionality (which is the point of this convenience routine).
*/
#include <stdio.h>
#include <epicsThread.h>
#include <epicsUnitTest.h>
int testEasyGetData(void);
int testEasyPutData(void);
int testEasyMonitorData(void);
int testEasyPutGetMonitor(void);
int testEasyPutGet(void);
int testEasyMultiDouble(void);
int testEasyNTMultiChannel(void);
void easyAllTests(void)
{
testHarness();
runTest(testEasyGetData);
runTest(testEasyPutData);
runTest(testEasyMonitorData);
runTest(testEasyPutMonitor);
runTest(testEasyPut);
runTest(testEasyMultiDouble);
runTest(testEasyNTMultiChannel);
}

31
test/src/pvaClientAllTests.c Normal file
View File

@@ -0,0 +1,31 @@
/*
* Run pvaClient tests as a batch.
*
* Do *not* include performance measurements here, they don't help to
* prove functionality (which is the point of this convenience routine).
*/
#include <stdio.h>
#include <epicsThread.h>
#include <epicsUnitTest.h>
int pvaClientTestGetData(void);
int pvaClientTestPutData(void);
int pvaClientTestMonitorData(void);
int pvaClientTestPutGetMonitor(void);
int pvaClientTestPutGet(void);
int pvaClientTestMultiDouble(void);
int pvaClientTestNTMultiChannel(void);
void easyAllTests(void)
{
testHarness();
runTest(pvaClientTestGetData);
runTest(pvaClientTestPutData);
runTest(pvaClientTestMonitorData);
runTest(pvaClientTestPutMonitor);
runTest(pvaClientTestPut);
runTest(pvaClientTestMultiDouble);
runTest(pvaClientTestNTMultiChannel);
}

74
test/src/testEasyGetData.cpp → test/src/pvaClientTestGetData.cpp
View File

@@ -1,4 +1,4 @@
/*testEasyGetData.cpp */
/*pvaClientTestGetData.cpp */
/**
* Copyright - See the COPYRIGHT that is included with this distribution.
* EPICS pvData is distributed subject to a Software License Agreement found
@@ -15,15 +15,15 @@
#include <epicsUnitTest.h>
#include <testMain.h>
#include <pv/easyPVA.h>
#include <pv/pvaClient.h>
#include <pv/bitSet.h>
using namespace std;
using namespace epics::pvData;
using namespace epics::pvAccess;
using namespace epics::easyPVA;
using namespace epics::pvaClient;
static EasyPVAPtr easyPVA = EasyPVA::create();
static PvaClientPtr pvaClient = PvaClient::create();
static FieldCreatePtr fieldCreate = getFieldCreate();
static StandardFieldPtr standardField = getStandardField();
static PVDataCreatePtr pvDataCreate = getPVDataCreate();
@@ -39,46 +39,46 @@ void testDouble()
add("value",pvDouble) ->
createStructure();
EasyGetDataPtr easyData = EasyGetData::create(structure);
PVStructurePtr pvStructure = pvDataCreate->createPVStructure(easyData->getStructure());
PvaClientGetDataPtr pvaData = PvaClientGetData::create(structure);
PVStructurePtr pvStructure = pvDataCreate->createPVStructure(pvaData->getStructure());
BitSetPtr bitSet = BitSetPtr(new BitSet(pvStructure->getNumberFields()));
easyData->setData(pvStructure,bitSet);
pvaData->setData(pvStructure,bitSet);
PVDoublePtr pvDouble = pvStructure->getSubField<PVDouble>("value");
size_t valueOffset = pvDouble->getFieldOffset();
BitSetPtr change = easyData->getBitSet();
BitSetPtr change = pvaData->getBitSet();
pvDouble->put(5.0);
change->set(pvDouble->getFieldOffset());
testOk(change->cardinality()==1,"num set bits 1");
testOk(change->get(valueOffset)==true,"value changed");
testOk(easyData->hasValue()==true,"hasValue");
testOk(easyData->isValueScalar()==true,"isValueScalar");
testOk(easyData->isValueScalarArray()==false,"isValueScalarArray");
testOk(pvaData->hasValue()==true,"hasValue");
testOk(pvaData->isValueScalar()==true,"isValueScalar");
testOk(pvaData->isValueScalarArray()==false,"isValueScalarArray");
bool result;
result = false;
if(easyData->getValue()) result = true;
if(pvaData->getValue()) result = true;
testOk(result==true,"getValue");
result = false;
if(easyData->getScalarValue()) result = true;
if(pvaData->getScalarValue()) result = true;
testOk(result==true,"getScalarValue");
try {
easyData->getArrayValue();
pvaData->getArrayValue();
} catch (std::runtime_error e) {
cout << "getArrayValue " << e.what() << endl;
}
try {
easyData->getScalarArrayValue();
pvaData->getScalarArrayValue();
} catch (std::runtime_error e) {
cout << " getScalarArrayValue " << e.what() << endl;
}
cout << "as double " << easyData->getDouble() << endl;
cout << "as string " << easyData->getString() << endl;
cout << "as double " << pvaData->getDouble() << endl;
cout << "as string " << pvaData->getString() << endl;
try {
shared_vector<const double> value = easyData->getDoubleArray();
shared_vector<const double> value = pvaData->getDoubleArray();
} catch (std::runtime_error e) {
cout << " getDoubleArray " << e.what() << endl;
}
try {
shared_vector<const string> value = easyData->getStringArray();
shared_vector<const string> value = pvaData->getStringArray();
} catch (std::runtime_error e) {
cout << " getStringArray " << e.what() << endl;
}
@@ -94,12 +94,12 @@ void testDoubleArray()
addArray("value",pvDouble) ->
createStructure();
EasyGetDataPtr easyData = EasyGetData::create(structure);
PVStructurePtr pvStructure = pvDataCreate->createPVStructure(easyData->getStructure());
PvaClientGetDataPtr pvaData = PvaClientGetData::create(structure);
PVStructurePtr pvStructure = pvDataCreate->createPVStructure(pvaData->getStructure());
BitSetPtr bitSet = BitSetPtr(new BitSet(pvStructure->getNumberFields()));
easyData->setData(pvStructure,bitSet);
PVDoubleArrayPtr pvalue = easyData->getPVStructure()->getSubField<PVDoubleArray>("value");
BitSetPtr change = easyData->getBitSet();
pvaData->setData(pvStructure,bitSet);
PVDoubleArrayPtr pvalue = pvaData->getPVStructure()->getSubField<PVDoubleArray>("value");
BitSetPtr change = pvaData->getBitSet();
size_t valueOffset = pvalue->getFieldOffset();
size_t len = 5;
shared_vector<double> value(len);
@@ -108,45 +108,45 @@ void testDoubleArray()
change->set(valueOffset);
testOk(change->cardinality()==1,"num set bits 1");
testOk(change->get(valueOffset)==true,"value changed");
testOk(easyData->hasValue()==true,"hasValue");
testOk(easyData->isValueScalar()==false,"isValueScalar");
testOk(easyData->isValueScalarArray()==true,"isValueScalarArray");
testOk(pvaData->hasValue()==true,"hasValue");
testOk(pvaData->isValueScalar()==false,"isValueScalar");
testOk(pvaData->isValueScalarArray()==true,"isValueScalarArray");
bool result;
result = false;
if(easyData->getValue()) result = true;
if(pvaData->getValue()) result = true;
testOk(result==true,"getValue");
result = false;
if(easyData->getArrayValue()) result = true;
if(pvaData->getArrayValue()) result = true;
testOk(result==true,"getArrayValue");
result = false;
if(easyData->getScalarArrayValue()) result = true;
if(pvaData->getScalarArrayValue()) result = true;
testOk(result==true,"getScalarValue");
try {
easyData->getScalarValue();
pvaData->getScalarValue();
} catch (std::runtime_error e) {
cout << " getScalarValue " << e.what() << endl;
}
try {
cout << "as double " << easyData->getDouble() << endl;
cout << "as double " << pvaData->getDouble() << endl;
} catch (std::runtime_error e) {
cout << " getDouble " << e.what() << endl;
}
try {
string val = easyData->getString();
string val = pvaData->getString();
} catch (std::runtime_error e) {
cout << " getString " << e.what() << endl;
}
cout << "as doubleArray " << easyData->getDoubleArray() << endl;
cout << "as doubleArray " << pvaData->getDoubleArray() << endl;
try {
shared_vector<const string> value = easyData->getStringArray();
shared_vector<const string> value = pvaData->getStringArray();
} catch (std::runtime_error e) {
cout << " getStringArray " << e.what() << endl;
}
}
MAIN(testEasyGetData)
MAIN(pvaClientTestGetData)
{
cout << "\nstarting testEasyGetData\n";
cout << "\nstarting pvaClientTestGetData\n";
testPlan(15);
testDouble();
testDoubleArray();

76
test/src/testEasyMonitorData.cpp → test/src/pvaClientTestMonitorData.cpp
View File

@@ -1,4 +1,4 @@
/*testEasyMonitorData.cpp */
/*pvaClientTestMonitorData.cpp */
/**
* Copyright - See the COPYRIGHT that is included with this distribution.
* EPICS pvData is distributed subject to a Software License Agreement found
@@ -15,15 +15,15 @@
#include <epicsUnitTest.h>
#include <testMain.h>
#include <pv/easyPVA.h>
#include <pv/pvaClient.h>
#include <pv/bitSet.h>
using namespace std;
using namespace epics::pvData;
using namespace epics::pvAccess;
using namespace epics::easyPVA;
using namespace epics::pvaClient;
static EasyPVAPtr easyPVA = EasyPVA::create();
static PvaClientPtr pvaClient = PvaClient::create();
static FieldCreatePtr fieldCreate = getFieldCreate();
static StandardFieldPtr standardField = getStandardField();
static PVDataCreatePtr pvDataCreate = getPVDataCreate();
@@ -39,45 +39,45 @@ void testDouble()
add("value",pvDouble) ->
createStructure();
EasyMonitorDataPtr easyData = EasyMonitorData::create(structure);
MonitorElementPtr monitorElement(new MonitorElement(pvDataCreate->createPVStructure(easyData->getStructure())));
easyData->setData(monitorElement);
PVDoublePtr pvDouble = easyData->getPVStructure()->getSubField<PVDouble>("value");
PvaClientMonitorDataPtr pvaData = PvaClientMonitorData::create(structure);
MonitorElementPtr monitorElement(new MonitorElement(pvDataCreate->createPVStructure(pvaData->getStructure())));
pvaData->setData(monitorElement);
PVDoublePtr pvDouble = pvaData->getPVStructure()->getSubField<PVDouble>("value");
size_t valueOffset = pvDouble->getFieldOffset();
BitSetPtr change = easyData->getChangedBitSet();
BitSetPtr change = pvaData->getChangedBitSet();
pvDouble->put(5.0);
change->set(pvDouble->getFieldOffset());
testOk(change->cardinality()==1,"num set bits 1");
testOk(change->get(valueOffset)==true,"value changed");
testOk(easyData->hasValue()==true,"hasValue");
testOk(easyData->isValueScalar()==true,"isValueScalar");
testOk(easyData->isValueScalarArray()==false,"isValueScalarArray");
testOk(pvaData->hasValue()==true,"hasValue");
testOk(pvaData->isValueScalar()==true,"isValueScalar");
testOk(pvaData->isValueScalarArray()==false,"isValueScalarArray");
bool result;
result = false;
if(easyData->getValue()) result = true;
if(pvaData->getValue()) result = true;
testOk(result==true,"getValue");
result = false;
if(easyData->getScalarValue()) result = true;
if(pvaData->getScalarValue()) result = true;
testOk(result==true,"getScalarValue");
try {
easyData->getArrayValue();
pvaData->getArrayValue();
} catch (std::runtime_error e) {
cout << "getArrayValue " << e.what() << endl;
}
try {
easyData->getScalarArrayValue();
pvaData->getScalarArrayValue();
} catch (std::runtime_error e) {
cout << " getScalarArrayValue " << e.what() << endl;
}
cout << "as double " << easyData->getDouble() << endl;
cout << "as string " << easyData->getString() << endl;
cout << "as double " << pvaData->getDouble() << endl;
cout << "as string " << pvaData->getString() << endl;
try {
shared_vector<const double> value = easyData->getDoubleArray();
shared_vector<const double> value = pvaData->getDoubleArray();
} catch (std::runtime_error e) {
cout << " getDoubleArray " << e.what() << endl;
}
try {
shared_vector<const string> value = easyData->getStringArray();
shared_vector<const string> value = pvaData->getStringArray();
} catch (std::runtime_error e) {
cout << " getStringArray " << e.what() << endl;
}
@@ -93,11 +93,11 @@ void testDoubleArray()
addArray("value",pvDouble) ->
createStructure();
EasyMonitorDataPtr easyData = EasyMonitorData::create(structure);
MonitorElementPtr monitorElement(new MonitorElement(pvDataCreate->createPVStructure(easyData->getStructure())));
easyData->setData(monitorElement);
PVDoubleArrayPtr pvalue = easyData->getPVStructure()->getSubField<PVDoubleArray>("value");
BitSetPtr change = easyData->getChangedBitSet();
PvaClientMonitorDataPtr pvaData = PvaClientMonitorData::create(structure);
MonitorElementPtr monitorElement(new MonitorElement(pvDataCreate->createPVStructure(pvaData->getStructure())));
pvaData->setData(monitorElement);
PVDoubleArrayPtr pvalue = pvaData->getPVStructure()->getSubField<PVDoubleArray>("value");
BitSetPtr change = pvaData->getChangedBitSet();
size_t valueOffset = pvalue->getFieldOffset();
size_t len = 5;
shared_vector<double> value(len);
@@ -106,45 +106,45 @@ void testDoubleArray()
change->set(valueOffset);
testOk(change->cardinality()==1,"num set bits 1");
testOk(change->get(valueOffset)==true,"value changed");
testOk(easyData->hasValue()==true,"hasValue");
testOk(easyData->isValueScalar()==false,"isValueScalar");
testOk(easyData->isValueScalarArray()==true,"isValueScalarArray");
testOk(pvaData->hasValue()==true,"hasValue");
testOk(pvaData->isValueScalar()==false,"isValueScalar");
testOk(pvaData->isValueScalarArray()==true,"isValueScalarArray");
bool result;
result = false;
if(easyData->getValue()) result = true;
if(pvaData->getValue()) result = true;
testOk(result==true,"getValue");
result = false;
if(easyData->getArrayValue()) result = true;
if(pvaData->getArrayValue()) result = true;
testOk(result==true,"getArrayValue");
result = false;
if(easyData->getScalarArrayValue()) result = true;
if(pvaData->getScalarArrayValue()) result = true;
testOk(result==true,"getScalarValue");
try {
easyData->getScalarValue();
pvaData->getScalarValue();
} catch (std::runtime_error e) {
cout << " getScalarValue " << e.what() << endl;
}
try {
cout << "as double " << easyData->getDouble() << endl;
cout << "as double " << pvaData->getDouble() << endl;
} catch (std::runtime_error e) {
cout << " getDouble " << e.what() << endl;
}
try {
string val = easyData->getString();
string val = pvaData->getString();
} catch (std::runtime_error e) {
cout << " getString " << e.what() << endl;
}
cout << "as doubleArray " << easyData->getDoubleArray() << endl;
cout << "as doubleArray " << pvaData->getDoubleArray() << endl;
try {
shared_vector<const string> value = easyData->getStringArray();
shared_vector<const string> value = pvaData->getStringArray();
} catch (std::runtime_error e) {
cout << " getStringArray " << e.what() << endl;
}
}
MAIN(testEasyMonitorData)
MAIN(pvaClientTestMonitorData)
{
cout << "\nstarting testEasyMonitorData\n";
cout << "\nstarting pvaClientTestMonitorData\n";
testPlan(15);
testDouble();
testDoubleArray();

44
test/src/testEasyMultiDouble.cpp → test/src/pvaClientTestMultiDouble.cpp
View File

@@ -1,4 +1,4 @@
/*testEasyMultiDouble.cpp */
/*pvaClientTestMultiDouble.cpp */
/**
* Copyright - See the COPYRIGHT that is included with this distribution.
* EPICS pvData is distributed subject to a Software License Agreement found
@@ -12,22 +12,22 @@
#include <iostream>
#include <pv/easyMultiDouble.h>
#include <pv/pvaClientMultiDouble.h>
#include <epicsUnitTest.h>
#include <testMain.h>
using namespace std;
using namespace epics::pvData;
using namespace epics::pvAccess;
using namespace epics::easyPVA;
using namespace epics::pvaClient;
static void testGood(EasyPVAPtr const &easyPVA)
static void testGood(PvaClientPtr const &pvaClient)
{
bool isOk = true;
cout << "\nstarting testGood\n";
try {
EasyPVAPtr easyPVA(EasyPVA::create());
PvaClientPtr pvaClient(PvaClient::create());
size_t num = 5;
shared_vector<string> channelNames(num);
channelNames[0] = "exampleDouble01";
@@ -38,7 +38,7 @@ static void testGood(EasyPVAPtr const &easyPVA)
PVStringArrayPtr pvNames =
getPVDataCreate()->createPVScalarArray<PVStringArray>();
pvNames->replace(freeze(channelNames));
EasyMultiDoublePtr multiDouble(EasyMultiDouble::create(easyPVA,pvNames));
PvaClientMultiDoublePtr multiDouble(PvaClientMultiDouble::create(pvaClient,pvNames));
shared_vector<double> data = multiDouble->get();
cout << "initial " << data << endl;
for(size_t i=0; i<num; ++i) data[i] = data[i] + 1.1;
@@ -52,12 +52,12 @@ static void testGood(EasyPVAPtr const &easyPVA)
testOk(isOk==true,"all channels double");
}
static void testGoodMixed(EasyPVAPtr const &easyPVA)
static void testGoodMixed(PvaClientPtr const &pvaClient)
{
bool isOk = true;
cout << "\nstarting testGoodMixed\n";
try {
EasyPVAPtr easyPVA(EasyPVA::create());
PvaClientPtr pvaClient(PvaClient::create());
size_t num = 5;
shared_vector<string> channelNames(num);
channelNames[0] = "exampleByte";
@@ -68,7 +68,7 @@ static void testGoodMixed(EasyPVAPtr const &easyPVA)
PVStringArrayPtr pvNames =
getPVDataCreate()->createPVScalarArray<PVStringArray>();
pvNames->replace(freeze(channelNames));
EasyMultiDoublePtr multiDouble(EasyMultiDouble::create(easyPVA,pvNames));
PvaClientMultiDoublePtr multiDouble(PvaClientMultiDouble::create(pvaClient,pvNames));
shared_vector<double> data = multiDouble->get();
cout << "initial " << data << endl;
for(size_t i=0; i<num; ++i) data[i] = data[i] + 1.1;
@@ -82,12 +82,12 @@ static void testGoodMixed(EasyPVAPtr const &easyPVA)
testOk(isOk==true,"channels mixed type");
}
static void testChannelNotExist(EasyPVAPtr const &easyPVA)
static void testChannelNotExist(PvaClientPtr const &pvaClient)
{
bool isOk = true;
cout << "\nstarting testChannelNotExist\n";
try {
EasyPVAPtr easyPVA(EasyPVA::create());
PvaClientPtr pvaClient(PvaClient::create());
size_t num = 5;
shared_vector<string> channelNames(num);
channelNames[0] = "exampleDouble01";
@@ -98,7 +98,7 @@ static void testChannelNotExist(EasyPVAPtr const &easyPVA)
PVStringArrayPtr pvNames =
getPVDataCreate()->createPVScalarArray<PVStringArray>();
pvNames->replace(freeze(channelNames));
EasyMultiDoublePtr multiDouble(EasyMultiDouble::create(easyPVA,pvNames));
PvaClientMultiDoublePtr multiDouble(PvaClientMultiDouble::create(pvaClient,pvNames));
shared_vector<double> data = multiDouble->get();
cout << "initial " << data << endl;
for(size_t i=0; i<num; ++i) data[i] = data[i] + 1.1;
@@ -112,12 +112,12 @@ static void testChannelNotExist(EasyPVAPtr const &easyPVA)
testOk(isOk==false,"channel not exist");
}
static void testNonNumeric(EasyPVAPtr const &easyPVA)
static void testNonNumeric(PvaClientPtr const &pvaClient)
{
bool isOk = true;
cout << "\nstarting testNonNumeric\n";
try {
EasyPVAPtr easyPVA(EasyPVA::create());
PvaClientPtr pvaClient(PvaClient::create());
size_t num = 5;
shared_vector<string> channelNames(num);
channelNames[0] = "exampleDouble01";
@@ -128,7 +128,7 @@ static void testNonNumeric(EasyPVAPtr const &easyPVA)
PVStringArrayPtr pvNames =
getPVDataCreate()->createPVScalarArray<PVStringArray>();
pvNames->replace(freeze(channelNames));
EasyMultiDoublePtr multiDouble(EasyMultiDouble::create(easyPVA,pvNames));
PvaClientMultiDoublePtr multiDouble(PvaClientMultiDouble::create(pvaClient,pvNames));
shared_vector<double> data = multiDouble->get();
cout << "initial " << data << endl;
for(size_t i=0; i<num; ++i) data[i] = data[i] + 1.1;
@@ -142,15 +142,15 @@ static void testNonNumeric(EasyPVAPtr const &easyPVA)
testOk(isOk==false,"channel not numeric");
}
MAIN(testEasyMultiDouble)
MAIN(pvaClientTestMultiDouble)
{
cout << "\nstarting testEasyMultiDouble\n";
cout << "\nstarting pvaClientTestMultiDouble\n";
testPlan(4);
EasyPVAPtr easyPVA = EasyPVA::create();
testGood(easyPVA);
testGoodMixed(easyPVA);
testChannelNotExist(easyPVA);
testNonNumeric(easyPVA);
PvaClientPtr pvaClient = PvaClient::create();
testGood(pvaClient);
testGoodMixed(pvaClient);
testChannelNotExist(pvaClient);
testNonNumeric(pvaClient);
cout << "done\n";
return 0;
}

28
test/src/testEasyNTMultiChannel.cpp → test/src/pvaClientTestNTMultiChannel.cpp
View File

@@ -1,4 +1,4 @@
/*testEasyNTMultiChannel.cpp */
/*pvaClientTestNTMultiChannel.cpp */
/**
* Copyright - See the COPYRIGHT that is included with this distribution.
* EPICS pvData is distributed subject to a Software License Agreement found
@@ -12,25 +12,25 @@
#include <iostream>
#include <pv/easyNTMultiChannel.h>
#include <pv/pvaClientNTMultiChannel.h>
#include <epicsUnitTest.h>
#include <testMain.h>
using namespace std;
using namespace epics::pvData;
using namespace epics::pvAccess;
using namespace epics::easyPVA;
using namespace epics::pvaClient;
using namespace epics::nt;
using std::tr1::static_pointer_cast;
static void testGood(EasyPVAPtr const &easyPVA)
static void testGood(PvaClientPtr const &pvaClient)
{
PVDataCreatePtr pvDataCreate(getPVDataCreate());
bool isOk = true;
cout << "\nstarting testGood\n";
try {
EasyPVAPtr easyPVA(EasyPVA::create());
PvaClientPtr pvaClient(PvaClient::create());
size_t num = 5;
shared_vector<string> channelNames(num);
channelNames[0] = "exampleDouble";
@@ -51,9 +51,9 @@ static void testGood(EasyPVAPtr const &easyPVA)
addNanoseconds() ->
addUserTag() ->
createStructure();
EasyNTMultiChannelPtr easy = EasyNTMultiChannel::create(
easyPVA,pvNames,structure);
NTMultiChannelPtr nt = easy->get();
PvaClientNTMultiChannelPtr multi = PvaClientNTMultiChannel::create(
pvaClient,pvNames,structure);
NTMultiChannelPtr nt = multi->get();
for(size_t numtimes=0; numtimes<3; ++numtimes) {
PVUnionArrayPtr pvValue = nt->getPVStructure()->
getSubField<PVUnionArray>("value");
@@ -109,8 +109,8 @@ static void testGood(EasyPVAPtr const &easyPVA)
}
}
pvValue->replace(freeze(valueVector));
easy->put(nt);
nt = easy->get();
multi->put(nt);
nt = multi->get();
}
cout << "final\n" << nt->getPVStructure() << endl;
} catch (std::runtime_error e) {
@@ -121,12 +121,12 @@ static void testGood(EasyPVAPtr const &easyPVA)
}
MAIN(testEasyNTMultiChannel)
MAIN(pvaClientTestNTMultiChannel)
{
cout << "\nstarting testEasyNTMultiChannel\n";
cout << "\nstarting pvaClientTestNTMultiChannel\n";
testPlan(1);
EasyPVAPtr easyPVA = EasyPVA::create();
testGood(easyPVA);
PvaClientPtr pvaClient = PvaClient::create();
testGood(pvaClient);
cout << "done\n";
return 0;
}

94
test/src/testEasyPutData.cpp → test/src/pvaClientTestPutData.cpp
View File

@@ -1,4 +1,4 @@
/*testEasyPutData.cpp */
/*pvaClientTestPutData.cpp */
/**
* Copyright - See the COPYRIGHT that is included with this distribution.
* EPICS pvData is distributed subject to a Software License Agreement found
@@ -15,15 +15,15 @@
#include <epicsUnitTest.h>
#include <testMain.h>
#include <pv/easyPVA.h>
#include <pv/pvaClient.h>
#include <pv/bitSet.h>
using namespace std;
using namespace epics::pvData;
using namespace epics::pvAccess;
using namespace epics::easyPVA;
using namespace epics::pvaClient;
static EasyPVAPtr easyPVA = EasyPVA::create();
static PvaClientPtr pvaClient = PvaClient::create();
static FieldCreatePtr fieldCreate = getFieldCreate();
static StandardFieldPtr standardField = getStandardField();
static PVDataCreatePtr pvDataCreate = getPVDataCreate();
@@ -49,9 +49,9 @@ static void testPostPut()
endNested()->
createStructure();
EasyPutDataPtr easyData = EasyPutData::create(structure);
PVStructurePtr pvStructure = easyData->getPVStructure();
BitSetPtr change = easyData->getBitSet();
PvaClientPutDataPtr pvaData = PvaClientPutData::create(structure);
PVStructurePtr pvStructure = pvaData->getPVStructure();
BitSetPtr change = pvaData->getBitSet();
PVDoublePtr powerValue = pvStructure->getSubField<PVDouble>("power.value");
PVDoublePtr voltageValue = pvStructure->getSubField<PVDouble>("voltage.value");
PVDoublePtr currentValue = pvStructure->getSubField<PVDouble>("current.value");
@@ -63,7 +63,7 @@ static void testPostPut()
voltageValue->put(2.0);
currentValue->put(.5);
cout << "changed\n";
cout << easyData->showChanged(cout) << endl;
cout << pvaData->showChanged(cout) << endl;
testOk(change->cardinality()==3,"num set bits 3");
testOk(change->get(powerOffset)==true,"power changed");
testOk(change->get(voltageOffset)==true,"voltage changed");
@@ -80,52 +80,52 @@ void testDouble()
add("value",pvDouble) ->
createStructure();
EasyPutDataPtr easyData = EasyPutData::create(structure);
PVDoublePtr pvDouble = easyData->getPVStructure()->getSubField<PVDouble>("value");
PvaClientPutDataPtr pvaData = PvaClientPutData::create(structure);
PVDoublePtr pvDouble = pvaData->getPVStructure()->getSubField<PVDouble>("value");
pvDouble->put(5.0);
BitSetPtr change = easyData->getBitSet();
BitSetPtr change = pvaData->getBitSet();
size_t valueOffset = pvDouble->getFieldOffset();
testOk(change->cardinality()==1,"num set bits 1");
testOk(change->get(valueOffset)==true,"value changed");
testOk(easyData->hasValue()==true,"hasValue");
testOk(easyData->isValueScalar()==true,"isValueScalar");
testOk(easyData->isValueScalarArray()==false,"isValueScalarArray");
testOk(pvaData->hasValue()==true,"hasValue");
testOk(pvaData->isValueScalar()==true,"isValueScalar");
testOk(pvaData->isValueScalarArray()==false,"isValueScalarArray");
bool result;
result = false;
if(easyData->getValue()) result = true;
if(pvaData->getValue()) result = true;
testOk(result==true,"getValue");
result = false;
if(easyData->getScalarValue()) result = true;
if(pvaData->getScalarValue()) result = true;
testOk(result==true,"getScalarValue");
try {
easyData->getArrayValue();
pvaData->getArrayValue();
} catch (std::runtime_error e) {
cout << "getArrayValue " << e.what() << endl;
}
try {
easyData->getScalarArrayValue();
pvaData->getScalarArrayValue();
} catch (std::runtime_error e) {
cout << " getScalarArrayValue " << e.what() << endl;
}
cout << "as double " << easyData->getDouble() << endl;
cout << "as string " << easyData->getString() << endl;
cout << "as double " << pvaData->getDouble() << endl;
cout << "as string " << pvaData->getString() << endl;
try {
shared_vector<const double> value = easyData->getDoubleArray();
shared_vector<const double> value = pvaData->getDoubleArray();
} catch (std::runtime_error e) {
cout << " getDoubleArray " << e.what() << endl;
}
try {
shared_vector<const string> value = easyData->getStringArray();
shared_vector<const string> value = pvaData->getStringArray();
} catch (std::runtime_error e) {
cout << " getStringArray " << e.what() << endl;
}
easyData->putDouble(5.0);
easyData->putString("1e5");
pvaData->putDouble(5.0);
pvaData->putString("1e5");
try {
size_t len = 2;
shared_vector<double> val(len);
for(size_t i=0; i<len; ++i) val[i] = (i+1)*10.0;
easyData->putDoubleArray(freeze(val));
pvaData->putDoubleArray(freeze(val));
} catch (std::runtime_error e) {
cout << " putDoubleArray " << e.what() << endl;
}
@@ -133,7 +133,7 @@ void testDouble()
size_t len = 2;
shared_vector<string> val(len);
val[0] = "one"; val[1] = "two";
easyData->putStringArray(freeze(val));
pvaData->putStringArray(freeze(val));
} catch (std::runtime_error e) {
cout << " putStringArray " << e.what() << endl;
}
@@ -149,78 +149,78 @@ void testDoubleArray()
addArray("value",pvDouble) ->
createStructure();
EasyPutDataPtr easyData = EasyPutData::create(structure);
PVDoubleArrayPtr pvalue = easyData->getPVStructure()->getSubField<PVDoubleArray>("value");
PvaClientPutDataPtr pvaData = PvaClientPutData::create(structure);
PVDoubleArrayPtr pvalue = pvaData->getPVStructure()->getSubField<PVDoubleArray>("value");
size_t len = 5;
shared_vector<double> value(len);
for(size_t i=0; i<len; ++i) value[i] = i*10.0;
pvalue->replace(freeze(value));
BitSetPtr change = easyData->getBitSet();
BitSetPtr change = pvaData->getBitSet();
size_t valueOffset = pvalue->getFieldOffset();
testOk(change->cardinality()==1,"num set bits 1");
testOk(change->get(valueOffset)==true,"value changed");
testOk(easyData->hasValue()==true,"hasValue");
testOk(easyData->isValueScalar()==false,"isValueScalar");
testOk(easyData->isValueScalarArray()==true,"isValueScalarArray");
testOk(pvaData->hasValue()==true,"hasValue");
testOk(pvaData->isValueScalar()==false,"isValueScalar");
testOk(pvaData->isValueScalarArray()==true,"isValueScalarArray");
bool result;
result = false;
if(easyData->getValue()) result = true;
if(pvaData->getValue()) result = true;
testOk(result==true,"getValue");
result = false;
if(easyData->getArrayValue()) result = true;
if(pvaData->getArrayValue()) result = true;
testOk(result==true,"getArrayValue");
result = false;
if(easyData->getScalarArrayValue()) result = true;
if(pvaData->getScalarArrayValue()) result = true;
testOk(result==true,"getScalarValue");
try {
easyData->getScalarValue();
pvaData->getScalarValue();
} catch (std::runtime_error e) {
cout << " getScalarValue " << e.what() << endl;
}
try {
cout << "as double " << easyData->getDouble() << endl;
cout << "as double " << pvaData->getDouble() << endl;
} catch (std::runtime_error e) {
cout << " getDouble " << e.what() << endl;
}
try {
string val = easyData->getString();
string val = pvaData->getString();
} catch (std::runtime_error e) {
cout << " getString " << e.what() << endl;
}
cout << "as doubleArray " << easyData->getDoubleArray() << endl;
cout << "as doubleArray " << pvaData->getDoubleArray() << endl;
try {
shared_vector<const string> value = easyData->getStringArray();
shared_vector<const string> value = pvaData->getStringArray();
} catch (std::runtime_error e) {
cout << " getStringArray " << e.what() << endl;
}
try {
easyData->putDouble(5.0);
pvaData->putDouble(5.0);
} catch (std::runtime_error e) {
cout << " putDouble " << e.what() << endl;
}
try {
easyData->putString("1e5");
pvaData->putString("1e5");
} catch (std::runtime_error e) {
cout << " putString " << e.what() << endl;
}
value = shared_vector<double>(len);
for(size_t i=0; i<len; ++i) value[i] = (i+1)* 2;
easyData->putDoubleArray(freeze(value));
cout << "as doubleArray " << easyData->getDoubleArray() << endl;
pvaData->putDoubleArray(freeze(value));
cout << "as doubleArray " << pvaData->getDoubleArray() << endl;
try {
size_t len = 2;
shared_vector<string> val(len);
val[0] = "one"; val[1] = "two";
easyData->putStringArray(freeze(val));
pvaData->putStringArray(freeze(val));
cout << "as stringArray " << val << endl;
} catch (std::runtime_error e) {
cout << " putStringArray " << e.what() << endl;
}
}
MAIN(testEasyPutData)
MAIN(pvaClientTestPutData)
{
cout << "\nstarting testEasyPutData\n";
cout << "\nstarting pvaClientTestPutData\n";
testPlan(19);
testPostPut();
testDouble();

30
test/src/testEasyPutGet.cpp → test/src/pvaClientTestPutGet.cpp
View File

@@ -1,4 +1,4 @@
/*exampleEasyPutGet.cpp */
/*pvaClientTestPutGet.cpp */
/**
* Copyright - See the COPYRIGHT that is included with this distribution.
* EPICS pvData is distributed subject to a Software License Agreement found
@@ -12,26 +12,30 @@
#include <iostream>
#include <pv/easyPVA.h>
#include <pv/pvaClient.h>
#include <epicsUnitTest.h>
#include <testMain.h>
using namespace std;
using namespace epics::pvData;
using namespace epics::pvAccess;
using namespace epics::easyPVA;
using namespace epics::pvaClient;
static void example(EasyPVAPtr const &easyPVA)
static void example(PvaClientPtr const &pvaClient)
{
cout << "\nstarting channelPutGet example\n";
try {
EasyChannelPtr easyChannel = easyPVA->createChannel("examplePowerSupply");
easyChannel->connect(2.0);
cout << "calling createChannel\n";
PvaClientChannelPtr pvaChannel = pvaClient->createChannel("examplePowerSupply");
cout << "calling connect\n";
pvaChannel->connect(2.0);
testOk(true==true,"connected");
EasyPutGetPtr putGet = easyChannel->createPutGet(
cout << "calling createPutGet\n";
PvaClientPutGetPtr putGet = pvaChannel->createPutGet(
"putField(power.value,voltage.value)getField()");
EasyPutDataPtr putData = putGet->getPutData();
cout << "calling getPutData\n";
PvaClientPutDataPtr putData = putGet->getPutData();
testOk(true==true,"put connected");
PVStructurePtr pvStructure = putData->getPVStructure();
PVDoublePtr power = pvStructure->getSubField<PVDouble>("power.value");
@@ -39,7 +43,7 @@ static void example(EasyPVAPtr const &easyPVA)
power->put(5.0);
voltage->put(5.0);
putGet->putGet();
EasyGetDataPtr getData = putGet->getGetData();
PvaClientGetDataPtr getData = putGet->getGetData();
pvStructure = getData->getPVStructure();
BitSetPtr bitSet = getData->getBitSet();
cout << "changed " << getData->showChanged(cout) << endl;
@@ -55,12 +59,12 @@ static void example(EasyPVAPtr const &easyPVA)
}
MAIN(testEasyPutGet)
MAIN(pvaClientTestPutGet)
{
cout << "\nstarting testEasyPutGet\n";
cout << "\nstarting pvaClientTestPutGet\n";
testPlan(2);
EasyPVAPtr easyPVA = EasyPVA::create();
example(easyPVA);
PvaClientPtr pvaClient = PvaClient::create();
example(pvaClient);
cout << "done\n";
return 0;
}

44
test/src/testEasyPutGetMonitor.cpp → test/src/pvaClientTestPutGetMonitor.cpp
View File

@@ -1,4 +1,4 @@
/*testEasyPutGetMonitor.cpp */
/*pvaClientTestPutGetMonitor.cpp */
/**
* Copyright - See the COPYRIGHT that is included with this distribution.
* EPICS pvData is distributed subject to a Software License Agreement found
@@ -12,52 +12,52 @@
#include <iostream>
#include <pv/easyPVA.h>
#include <pv/pvaClient.h>
#include <epicsUnitTest.h>
#include <testMain.h>
using namespace std;
using namespace epics::pvData;
using namespace epics::pvAccess;
using namespace epics::easyPVA;
using namespace epics::pvaClient;
class MyMonitor : public EasyMonitorRequester
class MyMonitor : public PvaClientMonitorRequester
{
public:
MyMonitor() {}
virtual ~MyMonitor() {}
virtual void event(EasyMonitorPtr monitor)
virtual void event(PvaClientMonitorPtr monitor)
{
while(true) {
if(!monitor->poll()) return;
EasyMonitorDataPtr easyData = monitor->getData();
PvaClientMonitorDataPtr pvaData = monitor->getData();
cout << "changed\n";
easyData->showChanged(cout);
pvaData->showChanged(cout);
cout << "overrun\n";
easyData->showOverrun(cout);
pvaData->showOverrun(cout);
monitor->releaseEvent();
}
}
};
static void exampleDouble(EasyPVAPtr const &easyPVA)
static void exampleDouble(PvaClientPtr const &pvaClient)
{
cout << "\nstarting exampleDouble\n";
try {
cout << "long way\n";
EasyChannelPtr easyChannel = easyPVA->createChannel("exampleDouble");
easyChannel->connect(2.0);
PvaClientChannelPtr pvaChannel = pvaClient->createChannel("exampleDouble");
pvaChannel->connect(2.0);
testOk(true==true,"connected");
EasyPutPtr put = easyChannel->createPut();
EasyPutDataPtr putData = put->getData();
PvaClientPutPtr put = pvaChannel->createPut();
PvaClientPutDataPtr putData = put->getData();
testOk(true==true,"put connected");
EasyGetPtr get = easyChannel->createGet();
EasyGetDataPtr getData = get->getData();
PvaClientGetPtr get = pvaChannel->createGet();
PvaClientGetDataPtr getData = get->getData();
testOk(true==true,"get connected");
EasyMonitorRequesterPtr requester(new MyMonitor());
EasyMonitorPtr monitor = easyChannel->monitor(requester);
PvaClientMonitorRequesterPtr requester(new MyMonitor());
PvaClientMonitorPtr monitor = pvaChannel->monitor(requester);
testOk(true==true,"monitor connected");
double out;
double in;
@@ -69,7 +69,7 @@ static void exampleDouble(EasyPVAPtr const &easyPVA)
in = getData->getDouble();
cout << "out " << out << " in " << in << endl;
}
EasyProcessPtr process = easyChannel->createProcess();
PvaClientProcessPtr process = pvaChannel->createProcess();
process->connect();
process->process();
} catch (std::runtime_error e) {
@@ -78,12 +78,12 @@ static void exampleDouble(EasyPVAPtr const &easyPVA)
}
MAIN(testEasyPutGetMonitor)
MAIN(pvaClientTestPutGetMonitor)
{
cout << "\nstarting testEasyPutGetMonitor\n";
cout << "\nstarting pvaClientTestPutGetMonitor\n";
testPlan(4);
EasyPVAPtr easyPVA = EasyPVA::create();
exampleDouble(easyPVA);
PvaClientPtr pvaClient = PvaClient::create();
exampleDouble(pvaClient);
cout << "done\n";
return 0;
}