void test_labels()
{
testDiag("test_labels");
NTTableBuilderPtr builder = NTTable::createBuilder();
testOk(builder.get() != 0, "Got builder");
PVStructurePtr pvStructure = builder->
addColumn("column0", pvDouble)->
addColumn("column1", pvString)->
addColumn("column2", pvInt)->
createPVStructure();
testOk1(pvStructure.get() != 0);
if (!pvStructure)
return;
testOk1(NTTable::isCompatible(pvStructure)==true);
std::cout << *pvStructure << std::endl;
PVStringArrayPtr labels = pvStructure->getSubField<PVStringArray>("labels");
testOk1(labels.get() != 0);
testOk1(labels->getLength() == 3);
PVStringArray::const_svector l(labels->view());
testOk1(l[0] == "column0");
testOk1(l[1] == "column1");
testOk1(l[2] == "column2");
}
void testGet(bool debug,GatherV3DataPtr gather)
{
String builder;
NTTablePtr nttable = gather->getNTTable();
bool result = gather->get();
if(!result) printf("get failed\n%s\n",gather->getMessage().c_str());
if(debug) {
builder.clear();
nttable->getPVStructure()->toString(&builder);
printf("nttable\n%s\n",builder.c_str());
}
PVDoubleArrayPtr values = gather->getDoubleValue();
PVIntArrayPtr severitys = gather->getAlarmSeverity();
PVBooleanArrayPtr isConnecteds = gather->getIsConnected();
PVStringArrayPtr channelNames = gather->getChannelName();
if(debug) {
builder.clear();
values->toString(&builder);
printf("value: %s\n",builder.c_str());
builder.clear();
severitys->toString(&builder);
printf("severity: %s\n",builder.c_str());
builder.clear();
isConnecteds->toString(&builder);
printf("isConnected: %s\n",builder.c_str());
builder.clear();
channelNames->toString(&builder);
printf("channelName: %s\n",builder.c_str());
}
}
static PyObject * _getLabels(PyObject *willBeNull, PyObject *args)
{
PyObject *pcapsule = 0;
if(!PyArg_ParseTuple(args,"O:nttablePy",
&pcapsule))
{
PyErr_SetString(PyExc_SyntaxError,
"Bad argument. Expected (pvt)");
return NULL;
}
void *pvoid = PyCapsule_GetPointer(pcapsule,"nttablePvt");
if(pvoid==0) {
PyErr_SetString(PyExc_SyntaxError,
"first arg must be return from _init");
return NULL;
}
NTTablePvt *pvt = static_cast<NTTablePvt *>(pvoid);
PVStringArrayPtr pvLabel = pvt->nttable->getLabels();
shared_vector<const string> data(pvLabel->view());
int num = data.size();
PyObject *result = PyTuple_New(num);
for(int i=0; i<num; i++) {
PyObject *elem = Py_BuildValue("s",data[i].c_str());
PyTuple_SetItem(result, i, elem);
}
return result;
}
PVStringArrayPtr PVDatabase::getRecordNames()
{
lock();
try {
PVStringArrayPtr xxx;
if(isDestroyed) {
unlock();
return xxx;
}
PVStringArrayPtr pvStringArray = static_pointer_cast<PVStringArray>
(getPVDataCreate()->createPVScalarArray(pvString));
size_t len = recordMap.size();
shared_vector<string> names(len);
PVRecordMap::iterator iter;
size_t i = 0;
for(iter = recordMap.begin(); iter!=recordMap.end(); ++iter) {
names[i++] = (*iter).first;
}
shared_vector<const string> temp(freeze(names));
pvStringArray->replace(temp);
unlock();
return pvStringArray;
} catch(...) {
unlock();
throw;
}
}
int main(int argc,char *argv[])
{
PVDatabasePtr master = PVDatabase::getMaster();
PVRecordPtr pvRecord;
bool result = false;
string recordName;
recordName = "exampleServer";
pvRecord = ExampleServer::create(recordName);
result = master->addRecord(pvRecord);
if(!result) cout<< "record " << recordName << " not added" << endl;
recordName = "traceRecordPGRPC";
pvRecord = TraceRecord::create(recordName);
result = master->addRecord(pvRecord);
if(!result) cout<< "record " << recordName << " not added" << endl;
ContextLocal::shared_pointer contextLocal = ContextLocal::create();
contextLocal->start();
PVStringArrayPtr pvNames = master->getRecordNames();
shared_vector<const string> names = pvNames->view();
for(size_t i=0; i<names.size(); ++i) cout << names[i] << endl;
contextLocal->waitForExit();
return 0;
}
static void setValue(PVUnionPtr const &pvUnion, double value)
{
UnionConstPtr u = pvUnion->getUnion();
FieldConstPtr field = u->getField(0);
Type type = field->getType();
if(type==scalar) {
ScalarConstPtr scalar = static_pointer_cast<const Scalar>(field);
ScalarType scalarType = scalar->getScalarType();
if(scalarType==pvDouble) {
PVDoublePtr pvValue = static_pointer_cast<PVDouble>(
pvDataCreate->createPVScalar(pvDouble));
pvValue->put(value);
pvUnion->set(0,pvValue);
return;
}
if(scalarType==pvString) {
PVStringPtr pvValue = static_pointer_cast<PVString>(
pvDataCreate->createPVScalar(pvString));
stringstream ss;
ss << "value" << value;
pvValue->put(ss.str());
pvUnion->set(0,pvValue);
return;
}
throw std::runtime_error("only pvDouble and pvString are supported");
}
if(type==scalarArray) {
ScalarArrayConstPtr scalarArray = static_pointer_cast<const ScalarArray>(field);
ScalarType scalarType = scalarArray->getElementType();
if(scalarType==pvDouble) {
size_t num = 5;
PVDoubleArrayPtr pvValue = static_pointer_cast<PVDoubleArray>(
pvDataCreate->createPVScalarArray(pvDouble));
shared_vector<double> data(num);
for(size_t i=0; i<num; ++i) data[i] = value +i;
pvValue->replace(freeze(data));
pvUnion->set(0,pvValue);
return;
}
if(scalarType==pvString) {
size_t num = 5;
PVStringArrayPtr pvValue = static_pointer_cast<PVStringArray>(
pvDataCreate->createPVScalarArray(pvString));
shared_vector<string> data(num);
for(size_t i=0; i<num; ++i) {
stringstream ss;
ss << "value" << value << i;
data[i] = ss.str();
}
pvValue->replace(freeze(data));
pvUnion->set(0,pvValue);
return;
}
throw std::runtime_error("only pvDouble and pvString are supported");
}
throw std::runtime_error("only scalar and scalarArray fields are supported");
}
void PvaClientPutData::putStringArray(shared_vector<const std::string> const & value)
{
checkValue();
PVStringArrayPtr pv = pvStructure->getSubField<PVStringArray>("value");
if(!pv) {
throw std::runtime_error(messagePrefix + notStringArray);
}
pv->replace(value);
}
shared_vector<const string> PvaClientPutData::getStringArray()
{
checkValue();
PVStringArrayPtr pv = pvStructure->getSubField<PVStringArray>("value");
if(!pv) {
throw std::runtime_error(messagePrefix + notStringArray);
}
return pv->view();
}
ChannelFind::shared_pointer ChannelProviderLocal::channelList(
ChannelListRequester::shared_pointer const & channelListRequester)
{
PVStringArrayPtr records;
{
Lock guard(mutex);
records = pvDatabase->getRecordNames();
}
channelListRequester->channelListResult(Status::Ok, channelFinder, records->view(), false);
return channelFinder;
}
bool PVEnumerated::attach(PVFieldPtr const & pvField)
{
if(pvField->getField()->getType()!=structure) return false;
PVStructurePtr pvStructure = static_pointer_cast<PVStructure>(pvField);
pvIndex = pvStructure->getSubField<PVInt>("index");
if(pvIndex.get()==NULL) return false;
PVStringArrayPtr pvStringArray = pvStructure->getSubField<PVStringArray>("choices");
if(pvStringArray.get()==NULL) {
pvIndex.reset();
return false;
}
pvChoices = pvStringArray;
return true;
}
void RecordListRecord::process()
{
PVStringArrayPtr pvNames = PVDatabase::getMaster()->getRecordNames();
name->replace(pvNames->view());
string message("");
if(database->get().compare("master")!=0) {
message += " can only access master ";
}
string regEx = regularExpression->get();
if(regEx.compare("")!=0 && regEx.compare(".*")!=0) {
message += " regularExpression not implemented ";
}
status->put(message);
}
PVStringArrayPtr PVDatabase::getRecordNames()
{
epicsGuard<epics::pvData::Mutex> guard(mutex);
PVStringArrayPtr xxx;
PVStringArrayPtr pvStringArray = static_pointer_cast<PVStringArray>
(getPVDataCreate()->createPVScalarArray(pvString));
size_t len = recordMap.size();
shared_vector<string> names(len);
PVRecordMap::iterator iter;
size_t i = 0;
for(iter = recordMap.begin(); iter!=recordMap.end(); ++iter) {
names[i++] = (*iter).first;
}
shared_vector<const string> temp(freeze(names));
pvStringArray->replace(temp);
return pvStringArray;
}
void test()
{
RPCClientPtr channelRPC =
RPCClientPtr(RPCClient::create(channelName));
bool result = channelRPC->connect(1.0);
if(!result) {
cout<< "connect failed\n";
return;
}
NTNameValueBuilderPtr builder = NTNameValue::createBuilder();
NTNameValuePtr ntnamevalue = builder ->
value(pvString) ->
add("function",fieldCreate->createScalar(pvString)) ->
create();
PVStructurePtr pv = ntnamevalue->getPVStructure();
PVStringPtr pvFunction = pv->getSubField<PVString>("function");
PVStringArrayPtr pvNames = pv->getSubField<PVStringArray>("name");
PVStringArrayPtr pvValues = pv->getSubField<PVStringArray>("value");
size_t n = 2;
shared_vector<string> name(n);
shared_vector<string> value(n);
name[0] = string("configname");
name[1] = string("servicename");
value[0] = string("test");
value[1] = string("masar");
pvNames->replace(freeze(name));
pvValues->replace(freeze(value));
pvFunction->put("retrieveSnapshot");
try {
cout << *ntnamevalue->getPVStructure() << endl;
PVStructurePtr pvResponse = channelRPC->request(ntnamevalue->getPVStructure());
cout << *pvResponse << endl;
} catch (std::exception &e)
{
cout << e.what() << endl;
return;
}
channelRPC->destroy();
}
static PyObject *getScalarArrayValue(PVScalarArrayPtr pvScalarArray)
{
ScalarType scalarType = pvScalarArray->getScalarArray()->getElementType();
switch(scalarType) {
case pvBoolean: {
PVBooleanArrayPtr pvArray = static_pointer_cast<PVBooleanArray>(pvScalarArray);
shared_vector<const boolean> data(pvArray->view());
int num = data.size();
PyObject *result = PyTuple_New(num);
for(int i=0; i<num; i++) {
int value = (data[i] ? 1 : 0);
PyObject *elem = Py_BuildValue("i",value);
PyTuple_SetItem(result, i, elem);
}
return result;
}
case pvByte: {
PVByteArrayPtr pvArray = static_pointer_cast<PVByteArray>(pvScalarArray);
shared_vector<const int8> data(pvArray->view());
int num = data.size();
PyObject *result = PyTuple_New(num);
for(int i=0; i<num; i++) {
int value = data[i];
PyObject *elem = Py_BuildValue("i",value);
PyTuple_SetItem(result, i, elem);
}
return result;
}
case pvUByte: {
PVUByteArrayPtr pvArray = static_pointer_cast<PVUByteArray>(pvScalarArray);
shared_vector<const uint8> data(pvArray->view());
int num = data.size();
PyObject *result = PyTuple_New(num);
for(int i=0; i<num; i++) {
int value = data[i];
PyObject *elem = Py_BuildValue("i",value);
PyTuple_SetItem(result, i, elem);
}
return result;
}
case pvShort: {
PVShortArrayPtr pvArray = static_pointer_cast<PVShortArray>(pvScalarArray);
shared_vector<const int16> data(pvArray->view());
int num = data.size();
PyObject *result = PyTuple_New(num);
for(int i=0; i<num; i++) {
int value = data[i];
PyObject *elem = Py_BuildValue("i",value);
PyTuple_SetItem(result, i, elem);
}
return result;
}
case pvUShort: {
PVUShortArrayPtr pvArray = static_pointer_cast<PVUShortArray>(pvScalarArray);
shared_vector<const uint16> data(pvArray->view());
int num = data.size();
PyObject *result = PyTuple_New(num);
for(int i=0; i<num; i++) {
int value = data[i];
PyObject *elem = Py_BuildValue("i",value);
PyTuple_SetItem(result, i, elem);
}
return result;
}
case pvInt: {
PVIntArrayPtr pvArray = static_pointer_cast<PVIntArray>(pvScalarArray);
shared_vector<const int32> data(pvArray->view());
int num = data.size();
PyObject *result = PyTuple_New(num);
for(int i=0; i<num; i++) {
PyObject *elem = Py_BuildValue("i",data[i]);
PyTuple_SetItem(result, i, elem);
}
return result;
}
case pvUInt: {
PVUIntArrayPtr pvArray = static_pointer_cast<PVUIntArray>(pvScalarArray);
shared_vector<const uint32> data(pvArray->view());
int num = data.size();
PyObject *result = PyTuple_New(num);
for(int i=0; i<num; i++) {
PyObject *elem = Py_BuildValue("i",data[i]);
PyTuple_SetItem(result, i, elem);
}
return result;
}
case pvLong: {
PVLongArrayPtr pvArray = static_pointer_cast<PVLongArray>(pvScalarArray);
shared_vector<const int64> data(pvArray->view());
int num = data.size();
PyObject *result = PyTuple_New(num);
for(int i=0; i<num; i++) {
PyObject *elem = Py_BuildValue("k",data[i]);
PyTuple_SetItem(result, i, elem);
}
return result;
}
case pvULong: {
PVULongArrayPtr pvArray = static_pointer_cast<PVULongArray>(pvScalarArray);
shared_vector<const uint64> data(pvArray->view());
int num = data.size();
PyObject *result = PyTuple_New(num);
for(int i=0; i<num; i++) {
PyObject *elem = Py_BuildValue("k",data[i]);
PyTuple_SetItem(result, i, elem);
}
return result;
}
case pvFloat: {
PVFloatArrayPtr pvArray = static_pointer_cast<PVFloatArray>(pvScalarArray);
shared_vector<const float> data(pvArray->view());
int num = data.size();
PyObject *result = PyTuple_New(num);
for(int i=0; i<num; i++) {
PyObject *elem = Py_BuildValue("f",data[i]);
PyTuple_SetItem(result, i, elem);
}
return result;
}
case pvDouble: {
PVDoubleArrayPtr pvArray = static_pointer_cast<PVDoubleArray>(pvScalarArray);
shared_vector<const double> data(pvArray->view());
int num = data.size();
PyObject *result = PyTuple_New(num);
for(int i=0; i<num; i++) {
PyObject *elem = Py_BuildValue("d",data[i]);
PyTuple_SetItem(result, i, elem);
}
return result;
}
case pvString: {
PVStringArrayPtr pvArray = static_pointer_cast<PVStringArray>(pvScalarArray);
shared_vector<const string> data(pvArray->view());
int num = data.size();
PyObject *result = PyTuple_New(num);
for(int i=0; i<num; i++) {
PyObject *elem = Py_BuildValue("s",data[i].c_str());
PyTuple_SetItem(result, i, elem);
}
return result;
}
}
Py_INCREF(Py_None);
return Py_None;
}
static void test()
{
NTMultiChannelBuilderPtr builder = NTMultiChannel::createBuilder();
testOk(builder.get() != 0, "Got builder");
NTMultiChannelPtr multiChannel = builder->
addDescriptor()->
addAlarm()->
addTimeStamp()->
addSeverity() ->
add("extra1",fieldCreate->createScalar(pvString)) ->
add("extra2",fieldCreate->createScalarArray(pvString)) ->
create();
testOk1(multiChannel.get() != 0);
PVStructurePtr pvStructure = multiChannel->getPVStructure();
testOk1(pvStructure.get()!=NULL);
testOk1(NTMultiChannel::is_a(pvStructure->getStructure()));
size_t nchan = 3;
shared_vector<string> names(nchan);
names[0] = "channel 0";
names[1] = "channel 1";
names[2] = "channel 2";
shared_vector<const string> channelNames(freeze(names));
PVStringArrayPtr pvChannelName = multiChannel->getChannelName();
pvChannelName->replace(channelNames);
if(debug) {cout << *pvStructure << endl;}
UnionConstPtr unionPtr =
fieldCreate->createFieldBuilder()->
add("doubleValue", pvDouble)->
add("intValue", pvInt)->
createUnion();
multiChannel = builder->
value(unionPtr) ->
addDescriptor()->
addAlarm()->
addTimeStamp()->
addSeverity() ->
addIsConnected() ->
create();
testOk1(multiChannel.get() != 0);
pvStructure = multiChannel->getPVStructure();
if(debug) {cout << *pvStructure << endl;}
pvChannelName = multiChannel->getChannelName();
pvChannelName->replace(channelNames);
PVUnionArrayPtr pvValue = multiChannel->getValue();
shared_vector<PVUnionPtr> unions(nchan);
unions[0] = pvDataCreate->createPVUnion(unionPtr);
unions[1] = pvDataCreate->createPVUnion(unionPtr);
unions[2] = pvDataCreate->createPVUnion(unionPtr);
unions[0]->select("doubleValue");
unions[1]->select("intValue");
unions[2]->select("intValue");
PVDoublePtr pvDouble = unions[0]->get<PVDouble>();
pvDouble->put(1.235);
PVIntPtr pvInt = unions[1]->get<PVInt>();
pvInt->put(5);
pvInt = unions[2]->get<PVInt>();
pvInt->put(7);
pvValue->replace(freeze(unions));
shared_vector<int32> severities(nchan);
severities[0] = 0;
severities[1] = 1;
severities[2] = 2;
PVIntArrayPtr pvSeverity = multiChannel->getSeverity();
pvSeverity->replace(freeze(severities));
if(debug) {cout << *pvStructure << endl;}
PVBooleanArrayPtr pvIsConnected = multiChannel->getIsConnected();
shared_vector<const epics::pvData::boolean> isConnected = pvIsConnected->view();
multiChannel = builder->
value(unionPtr) ->
addDescriptor()->
addAlarm()->
addTimeStamp()->
addSeverity() ->
addStatus() ->
addMessage() ->
addSecondsPastEpoch() ->
addNanoseconds() ->
addUserTag() ->
addIsConnected() ->
create();
testOk1(multiChannel.get() != 0);
pvStructure = multiChannel->getPVStructure();
if(debug) {cout << *pvStructure << endl;}
testOk1(NTMultiChannel::isCompatible(pvStructure)==true);
PVStructurePtr pvTimeStamp = multiChannel->getTimeStamp();
testOk1(pvTimeStamp.get() !=0);
PVStructurePtr pvAlarm = multiChannel->getAlarm();
testOk1(pvAlarm.get() !=0);
pvValue = multiChannel->getValue();
testOk1(pvValue.get() !=0);
pvChannelName = multiChannel->getChannelName();
testOk1(pvChannelName.get() !=0);
pvIsConnected = multiChannel->getIsConnected();
testOk1(pvIsConnected.get() !=0);
pvSeverity = multiChannel->getSeverity();
testOk1(pvSeverity.get() !=0);
PVIntArrayPtr pvStatus = multiChannel->getStatus();
testOk1(pvStatus.get() !=0);
PVStringArrayPtr pvMessage = multiChannel->getMessage();
testOk1(pvMessage.get() !=0);
PVLongArrayPtr pvSecondsPastEpoch = multiChannel->getSecondsPastEpoch();
testOk1(pvSecondsPastEpoch.get() !=0);
PVIntArrayPtr pvNanoseconds = multiChannel->getNanoseconds();
testOk1(pvNanoseconds.get() !=0);
PVIntArrayPtr pvUserTag = multiChannel->getUserTag();
testOk1(pvUserTag.get() !=0);
PVStringPtr pvDescriptor = multiChannel->getDescriptor();
testOk1(pvDescriptor.get() !=0);
}
void test_ntnameValue()
{
testDiag("test_ntnameValue");
NTNameValueBuilderPtr builder = NTNameValue::createBuilder();
testOk(builder.get() != 0, "Got builder");
NTNameValuePtr ntNameValue = builder->
value(pvInt)->
addDescriptor()->
addAlarm()->
addTimeStamp()->
add("extra1",fieldCreate->createScalar(pvString)) ->
add("extra2",fieldCreate->createScalarArray(pvString)) ->
create();
testOk1(ntNameValue.get() != 0);
testOk1(NTNameValue::is_a(ntNameValue->getPVStructure()));
testOk1(NTNameValue::isCompatible(ntNameValue->getPVStructure()));
testOk1(ntNameValue->getPVStructure().get() != 0);
testOk1(ntNameValue->getDescriptor().get() != 0);
testOk1(ntNameValue->getAlarm().get() != 0);
testOk1(ntNameValue->getTimeStamp().get() != 0);
testOk1(ntNameValue->getName().get() != 0);
testOk1(ntNameValue->getValue().get() != 0);
//
// example how to set name
//
PVStringArray::svector newName;
newName.push_back("name1");
newName.push_back("name2");
newName.push_back("name3");
PVStringArrayPtr pvNameField = ntNameValue->getName();
pvNameField->replace(freeze(newName));
//
// example how to get name
//
PVStringArray::const_svector name(pvNameField->view());
testOk1(name.size() == 3);
testOk1(name[0] == "name1");
testOk1(name[1] == "name2");
testOk1(name[2] == "name3");
//
// example how to set value
//
PVIntArray::svector newValue;
newValue.push_back(1);
newValue.push_back(2);
newValue.push_back(8);
PVIntArrayPtr pvValueField = ntNameValue->getValue<PVIntArray>();
pvValueField->replace(freeze(newValue));
//
// example how to get column value
//
PVIntArray::const_svector value(pvValueField->view());
testOk1(value.size() == 3);
testOk1(value[0] == 1);
testOk1(value[1] == 2);
testOk1(value[2] == 8);
//
// timeStamp ops
//
PVTimeStamp pvTimeStamp;
if (ntNameValue->attachTimeStamp(pvTimeStamp))
{
testPass("timeStamp attach");
// example how to set current time
TimeStamp ts;
ts.getCurrent();
pvTimeStamp.set(ts);
// example how to get EPICS time
TimeStamp ts2;
pvTimeStamp.get(ts2);
testOk1(ts2.getEpicsSecondsPastEpoch() != 0);
}
else
testFail("timeStamp attach fail");
//
// alarm ops
//
PVAlarm pvAlarm;
if (ntNameValue->attachAlarm(pvAlarm))
{
testPass("alarm attach");
// example how to set an alarm
Alarm alarm;
alarm.setStatus(deviceStatus);
alarm.setSeverity(minorAlarm);
alarm.setMessage("simulation alarm");
pvAlarm.set(alarm);
}
else
testFail("alarm attach fail");
//
// set descriptor
//
ntNameValue->getDescriptor()->put("This is a test NTNameValue");
// dump NTNameValue
std::cout << *ntNameValue->getPVStructure() << std::endl;
}
void test_ntenum()
{
testDiag("test_ntenum");
NTEnumBuilderPtr builder = NTEnum::createBuilder();
testOk(builder.get() != 0, "Got builder");
NTEnumPtr ntEnum = builder->
addDescriptor()->
addAlarm()->
addTimeStamp()->
add("valueAlarm",standardField->intAlarm()) ->
create();
testOk1(ntEnum.get() != 0);
testOk1(NTEnum::is_a(ntEnum->getPVStructure()));
testOk1(NTEnum::isCompatible(ntEnum->getPVStructure()));
testOk1(ntEnum->getPVStructure().get() != 0);
testOk1(ntEnum->getValue().get() != 0);
testOk1(ntEnum->getDescriptor().get() != 0);
testOk1(ntEnum->getAlarm().get() != 0);
testOk1(ntEnum->getTimeStamp().get() != 0);
//
// example how to set a value
//
PVStructurePtr pvValue = ntEnum->getValue();
//PVStringArray pvChoices = pvValue->getSubField<PVStringArray>("choices");
PVStringArray::svector choices(2);
choices[0] = "Off";
choices[1] = "On";
pvValue->getSubField<PVStringArray>("choices")->replace(freeze(choices));
pvValue->getSubField<PVInt>("index")->put(1);
//
// example how to get a value
//
int32 value = ntEnum->getValue()->getSubField<PVInt>("index")->get();
testOk1(value == 1);
PVStringArrayPtr pvChoices = ntEnum->getValue()->getSubField<PVStringArray>("choices");
std::string choice0 = pvChoices->view()[0];
std::string choice1 = pvChoices->view()[1];
testOk1(choice0 == "Off");
testOk1(choice1 == "On");
//
// timeStamp ops
//
PVTimeStamp pvTimeStamp;
if (ntEnum->attachTimeStamp(pvTimeStamp))
{
testPass("timeStamp attach");
// example how to set current time
TimeStamp ts;
ts.getCurrent();
pvTimeStamp.set(ts);
// example how to get EPICS time
TimeStamp ts2;
pvTimeStamp.get(ts2);
testOk1(ts2.getEpicsSecondsPastEpoch() != 0);
}
else
testFail("timeStamp attach fail");
//
// alarm ops
//
PVAlarm pvAlarm;
if (ntEnum->attachAlarm(pvAlarm))
{
testPass("alarm attach");
// example how to set an alarm
Alarm alarm;
alarm.setStatus(deviceStatus);
alarm.setSeverity(minorAlarm);
alarm.setMessage("simulation alarm");
pvAlarm.set(alarm);
}
else
testFail("alarm attach fail");
//
// set descriptor
//
ntEnum->getDescriptor()->put("This is a test NTEnum");
// dump ntEnum
std::cout << *ntEnum->getPVStructure() << std::endl;
}
void test_ntcontinuum()
{
testDiag("test_ntcontinuum");
NTContinuumBuilderPtr builder = NTContinuum::createBuilder();
testOk(builder.get() != 0, "Got builder");
NTContinuumPtr ntContinuum = builder->
addDescriptor()->
addAlarm()->
addTimeStamp()->
add("extra1",fieldCreate->createScalar(pvString)) ->
add("extra2",fieldCreate->createScalarArray(pvString)) ->
create();
testOk1(ntContinuum.get() != 0);
testOk1(ntContinuum->getPVStructure().get() != 0);
testOk1(ntContinuum->getDescriptor().get() != 0);
testOk1(ntContinuum->getAlarm().get() != 0);
testOk1(ntContinuum->getTimeStamp().get() != 0);
testOk1(ntContinuum->getBase().get() != 0);
testOk1(ntContinuum->getValue().get() != 0);
//
// example how to set base
//
PVDoubleArray::svector newBase;
newBase.push_back(1.0);
newBase.push_back(2.0);
PVDoubleArrayPtr pvBaseField = ntContinuum->getBase();
pvBaseField->replace(freeze(newBase));
//
// example how to get bases
//
PVDoubleArray::const_svector base(pvBaseField->view());
testOk1(base.size() == 2);
testOk1(base[0] == 1.0);
testOk1(base[1] == 2.0);
//
// example how to set values
//
PVDoubleArray::svector newValue;
newValue.push_back(1.0);
newValue.push_back(2.0);
newValue.push_back(10.0);
newValue.push_back(20.0);
newValue.push_back(100.0);
newValue.push_back(200.0);
PVDoubleArrayPtr pvValueField = ntContinuum->getValue();
pvValueField->replace(freeze(newValue));
//
// example how to get values
//
PVDoubleArray::const_svector value(pvValueField->view());
testOk1(value.size() == 6);
testOk1(value[0] == 1.0);
testOk1(value[1] == 2.0);
testOk1(value[2] == 10.0);
testOk1(value[3] == 20.0);
testOk1(value[4] == 100.0);
testOk1(value[5] == 200.0);
//
// example how to set units
//
PVStringArray::svector newUnits;
newUnits.push_back("s");
newUnits.push_back("ms");
newUnits.push_back("us");
newUnits.push_back("s");
PVStringArrayPtr pvUnitsField = ntContinuum->getUnits();
pvUnitsField->replace(freeze(newUnits));
//
// example how to get units
//
PVStringArray::const_svector units(pvUnitsField->view());
testOk1(units.size() == 4);
testOk1(units[0] == "s");
testOk1(units[1] == "ms");
testOk1(units[2] == "us");
testOk1(units[3] == "s");
//
// test isValid
//
testOk1(ntContinuum->isValid());
//
// timeStamp ops
//
PVTimeStamp pvTimeStamp;
if (ntContinuum->attachTimeStamp(pvTimeStamp))
{
testPass("timeStamp attach");
// example how to set current time
TimeStamp ts;
ts.getCurrent();
pvTimeStamp.set(ts);
// example how to get EPICS time
TimeStamp ts2;
pvTimeStamp.get(ts2);
testOk1(ts2.getEpicsSecondsPastEpoch() != 0);
}
else
testFail("timeStamp attach fail");
//
// alarm ops
//
PVAlarm pvAlarm;
if (ntContinuum->attachAlarm(pvAlarm))
{
testPass("alarm attach");
// example how to set an alarm
Alarm alarm;
alarm.setStatus(deviceStatus);
alarm.setSeverity(minorAlarm);
alarm.setMessage("simulation alarm");
pvAlarm.set(alarm);
}
else
testFail("alarm attach fail");
//
// set descriptor
//
ntContinuum->getDescriptor()->put("This is a test NTContinuum");
// dump NTContinuum
std::cout << *ntContinuum->getPVStructure() << std::endl;
}
void test()
{
String builder;
int n = 9;
StringArray channelName(n);
channelName[0] = "masarExample0000";
channelName[1] = "masarExample0001";
channelName[2] = "masarExample0002";
channelName[3] = "masarExample0003";
channelName[4] = "masarExample0004";
channelName[5] = "masarExampleCharArray";
channelName[6] = "masarExampleStringArray";
channelName[7] = "masarExampleLongArray";
channelName[8] = "masarExampleDoubleArray";
GatherV3DataPtr gather(new GatherV3Data(channelName,n));
bool result = gather->connect(5.0);
if(!result) {
printf("connect failed\n%s\n",gather->getMessage().c_str());
printf("This test requires iocBoot/iocAll ");
printf("It must be started before running this test\n");
exit(1);
}
NTTablePtr nttable = gather->getNTTable();
BooleanArrayData booldata;
PVBooleanArrayPtr pvIsArray = static_pointer_cast<PVBooleanArray>
(nttable->getPVStructure()->getScalarArrayField("isArray",pvBoolean));
pvIsArray->get(0,n,booldata);
BooleanArray & isArray = booldata.data;
DoubleArrayData ddata;
gather->getDoubleValue()->get(0,n,ddata);
DoubleArray & dvalue = ddata.data;
StringArrayData sdata;
gather->getStringValue()->get(0,n,sdata);
StringArray & svalue = sdata.data;
LongArrayData ldata;
gather->getLongValue()->get(0,n,ldata);
LongArray & lvalue = ldata.data;
IntArrayData idata;
StructureArrayData structdata;
gather->getArrayValue()->get(0,n,structdata);
PVStructurePtrArray & structvalue = structdata.data;
gather->getDBRType()->get(0,n,idata);
IntArray & dbrType = idata.data;
for(int i=0; i<n; i++) {
if(isArray[i]) {
PVStructurePtr pvStructure = structvalue[i];
switch(dbrType[i]) {
case DBF_STRING: {
PVStringArrayPtr pvValue = static_pointer_cast<PVStringArray>(
pvStructure->getScalarArrayField("stringValue",pvString));
int num = 4;
String value[4];
value[0] = "aaa";
value[1] = "bbb";
value[2] = "ccc";
value[3] = "ddd";
pvValue->put(0,num,value,0);
break;
}
case DBF_CHAR:
case DBF_INT:
case DBF_LONG: {
PVIntArrayPtr pvValue = static_pointer_cast<PVIntArray>(
pvStructure->getScalarArrayField("intValue",pvInt));
int num = 4;
int32 value[4] = {1,2,3,4};
pvValue->put(0,num,value,0);
break;
}
case DBF_FLOAT:
case DBF_DOUBLE: {
PVDoubleArrayPtr pvValue = static_pointer_cast<PVDoubleArray>(
pvStructure->getScalarArrayField("doubleValue",pvDouble));
int num = 4;
double value[4] = {1e1,1e2,1e3,1e4};
pvValue->put(0,num,value,0);
break;
}
default:
printf("got an unexpected DBF type. Logic error\n");
exit(1);
}
continue;
}
switch(dbrType[i]) {
case DBF_STRING:
svalue[i] = String("this is set by gatherV3DataPut"); break;
case DBF_ENUM:
svalue[i] = String("one"); break;
case DBF_CHAR:
case DBF_INT:
case DBF_LONG:
lvalue[i] = i; break;
case DBF_FLOAT:
case DBF_DOUBLE:
dvalue[i] = i; break;
default:
printf("got an unexpected DBF type. Logic error\n");
exit(1);
}
}
result = gather->put();
if(!result) {printf("put failed\n%s\n",gather->getMessage().c_str()); exit(1);}
result = gather->get();
if(!result) {printf("get failed\n%s\n",gather->getMessage().c_str()); exit(1);}
builder.clear();
nttable->getPVStructure()->toString(&builder);
printf("nttable\n%s\n",builder.c_str());
}
static void test()
{
NTScalarMultiChannelBuilderPtr builder = NTScalarMultiChannel::createBuilder();
testOk(builder.get() != 0, "Got builder");
NTScalarMultiChannelPtr multiChannel = builder->
addDescriptor()->
addAlarm()->
addTimeStamp()->
addSeverity() ->
add("extra1",fieldCreate->createScalar(pvString)) ->
add("extra2",fieldCreate->createScalarArray(pvString)) ->
create();
testOk1(multiChannel.get() != 0);
PVStructurePtr pvStructure = multiChannel->getPVStructure();
testOk1(pvStructure.get()!=NULL);
testOk1(NTScalarMultiChannel::is_a(pvStructure->getStructure()));
size_t nchan = 3;
shared_vector<string> names(nchan);
names[0] = "channel 0";
names[1] = "channel 1";
names[2] = "channel 2";
shared_vector<const string> channelNames(freeze(names));
PVStringArrayPtr pvChannelName = multiChannel->getChannelName();
pvChannelName->replace(channelNames);
if(debug) {cout << *pvStructure << endl;}
multiChannel = builder->
value(pvDouble) ->
addDescriptor()->
addAlarm()->
addTimeStamp()->
addSeverity() ->
addIsConnected() ->
create();
testOk1(multiChannel.get() != 0);
pvStructure = multiChannel->getPVStructure();
if(debug) {cout << *pvStructure << endl;}
pvChannelName = multiChannel->getChannelName();
pvChannelName->replace(channelNames);
PVDoubleArrayPtr pvValue = multiChannel->getValue<PVDoubleArray>();
PVDoubleArray::svector doubles(nchan);
doubles.resize(nchan);
doubles[0] = 3.14159;
doubles[1] = 2.71828;
doubles[2] = 137.036;
pvValue->replace(freeze(doubles));
shared_vector<int32> severities(nchan);
severities[0] = 0;
severities[1] = 1;
severities[2] = 2;
PVIntArrayPtr pvSeverity = multiChannel->getSeverity();
pvSeverity->replace(freeze(severities));
if(debug) {cout << *pvStructure << endl;}
PVBooleanArrayPtr pvIsConnected = multiChannel->getIsConnected();
shared_vector<const epics::pvData::boolean> isConnected = pvIsConnected->view();
multiChannel = builder->
value(pvDouble) ->
addDescriptor()->
addAlarm()->
addTimeStamp()->
addSeverity() ->
addStatus() ->
addMessage() ->
addSecondsPastEpoch() ->
addNanoseconds() ->
addUserTag() ->
addIsConnected() ->
create();
testOk1(multiChannel.get() != 0);
pvStructure = multiChannel->getPVStructure();
if(debug) {cout << *pvStructure << endl;}
testOk1(NTScalarMultiChannel::isCompatible(pvStructure)==true);
PVStructurePtr pvTimeStamp = multiChannel->getTimeStamp();
testOk1(pvTimeStamp.get() !=0);
PVStructurePtr pvAlarm = multiChannel->getAlarm();
testOk1(pvAlarm.get() !=0);
pvValue = multiChannel->getValue<PVDoubleArray>();
testOk1(pvValue.get() !=0);
pvChannelName = multiChannel->getChannelName();
testOk1(pvChannelName.get() !=0);
pvIsConnected = multiChannel->getIsConnected();
testOk1(pvIsConnected.get() !=0);
pvSeverity = multiChannel->getSeverity();
testOk1(pvSeverity.get() !=0);
PVIntArrayPtr pvStatus = multiChannel->getStatus();
testOk1(pvStatus.get() !=0);
PVStringArrayPtr pvMessage = multiChannel->getMessage();
testOk1(pvMessage.get() !=0);
PVLongArrayPtr pvSecondsPastEpoch = multiChannel->getSecondsPastEpoch();
testOk1(pvSecondsPastEpoch.get() !=0);
PVIntArrayPtr pvNanoseconds = multiChannel->getNanoseconds();
testOk1(pvNanoseconds.get() !=0);
PVIntArrayPtr pvUserTag = multiChannel->getUserTag();
testOk1(pvUserTag.get() !=0);
PVStringPtr pvDescriptor = multiChannel->getDescriptor();
testOk1(pvDescriptor.get() !=0);
}
void ExampleServiceRPC::request(
ChannelRPCRequester::shared_pointer const & channelRPCRequester,
epics::pvData::PVStructure::shared_pointer const & pvArgument)
{
String buffer;
PVStringPtr pvfunction = pvArgument->getStringField("function");
PVStringArrayPtr pvnames = static_pointer_cast<PVStringArray>
(pvArgument->getScalarArrayField("names",pvString));
PVStringArrayPtr pvvalues = static_pointer_cast<PVStringArray>
(pvArgument->getScalarArrayField("values",pvString));
buffer += "pvArgument ";
bool is = true;
if(pvfunction==0) is = false;
if(pvnames==0) is = false;
if(pvvalues==0) is = false;
if(is) {
buffer += "is a NTNameValue\n";
} else {
buffer += "is not a NTNameValue\n ";
}
pvArgument->toString(&buffer);
printf("%s\n",buffer.c_str());
StandardFieldPtr standardField = getStandardField();
StandardPVFieldPtr standardPVField = getStandardPVField();
FieldCreatePtr fieldCreate = getFieldCreate();
PVDataCreatePtr pvDataCreate = getPVDataCreate();
size_t n = 5;
FieldConstPtrArray fields;
StringArray names;
fields.reserve(n);
names.reserve(n);
names.push_back("alarm");
names.push_back("timeStamp");
names.push_back("label");
names.push_back("position");
names.push_back("alarms");
StructureConstPtr xxx = standardField->alarm();
printf("xxx %p\n",xxx.get());
fields.push_back(standardField->alarm());
fields.push_back(standardField->timeStamp());
fields.push_back(fieldCreate->createScalarArray(pvString));
fields.push_back(fieldCreate->createScalarArray(pvDouble));
fields.push_back(fieldCreate->createStructureArray(standardField->alarm()));
StructureConstPtr structure = fieldCreate->createStructure(names,fields);
printf("structure %p\n",structure.get());
buffer.clear();
structure->toString(&buffer);
printf("structure\n%s\n",buffer.c_str());
PVStructurePtr pvStructure = pvDataCreate->createPVStructure(structure);
PVTimeStamp pvTimeStamp;
TimeStamp timeStamp;
pvTimeStamp.attach(pvStructure->getStructureField("timeStamp"));
timeStamp.getCurrent();
pvTimeStamp.set(timeStamp);
StringArray label;
label.reserve(2);
for(int i=0; i<2; i++) {
label.push_back(names[i+3]);
}
PVStringArrayPtr pvLabel = static_pointer_cast<PVStringArray>
(pvStructure->getScalarArrayField("label",pvString));
pvLabel->put(0,2,label,0);
PVDoubleArrayPtr pvPositions = static_pointer_cast<PVDoubleArray>
(pvStructure->getScalarArrayField("position",pvDouble));
double positions[2];
positions[0] = 1.0;
positions[1] = 2.0;
pvPositions->put(0,2,positions,0);
PVStructureArrayPtr pvAlarms = static_pointer_cast<PVStructureArray>
(pvStructure->getStructureArrayField("alarms"));
PVAlarm pvAlarm;
Alarm alarm;
PVStructurePtrArray palarms;
size_t na=2;
palarms.reserve(na);
for(size_t i=0; i<na; i++) {
palarms.push_back(pvDataCreate->createPVStructure(standardField->alarm()));
}
for(size_t i=0; i<na; i++) {
pvAlarm.attach(palarms[i]);
alarm.setMessage("test");
alarm.setSeverity(majorAlarm);
alarm.setStatus(clientStatus);
pvAlarm.set(alarm);
}
pvAlarms->put(0,2,palarms,0);
String labels[2];
labels[0] = pvPositions->getFieldName();
labels[1] = pvAlarms->getFieldName();
pvLabel->put(0,2,labels,0);
buffer.erase();
pvStructure->toString(&buffer);
printf("%s\n",buffer.c_str());
channelRPCRequester->requestDone(Status::Ok,pvStructure);
}
