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

builds and tests work. must still look carefully

Browse Source
This commit is contained in:
Marty Kraimer
2012-08-02 09:47:19 -04:00
parent 42c6c2dc38
commit 0f251f5eb1
8 changed files with 213 additions and 284 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
src/nt/ntfield.cpp
View File

@@ -150,7 +150,7 @@ bool NTField::isAlarmLimit(FieldConstPtr const & field)
if(names[0].compare("active")!=0) return false;
if(f->getType()!=scalar) return false;
ScalarConstPtr s = static_pointer_cast<const Scalar>(f);
if(s->getScalarType()!=pvDouble) return false;
if(s->getScalarType()!=pvBoolean) return false;
f = fields[1];
if(names[1].compare("lowAlarmLimit")!=0) return false;
if(f->getType()!=scalar) return false;

109
src/nt/ntnameValue.cpp
View File

@@ -11,15 +11,14 @@ namespace epics { namespace pvData {
using std::tr1::static_pointer_cast;
bool NTNameValue::isNTNameValue(PVStructurePtr pvStructure)
bool NTNameValue::isNTNameValue(PVStructurePtr const & pvStructure)
{
String name = pvStructure->getField()->getFieldName();
if(name.compare("NTNameValue")!=0) return false;
PVFieldPtr pvField = pvStructure->getSubField("names");
if(pvField==0) return false;
if(pvField.get()==NULL) return false;
FieldConstPtr field = pvField->getField();
if(field->getType()!=scalarArray) return false;
ScalarArrayConstPtr pscalarArray = static_pointer_cast<const ScalarArray>(field);
ScalarArrayConstPtr pscalarArray =
static_pointer_cast<const ScalarArray>(field);
if(pscalarArray->getElementType()!=pvString) return false;
pvField = pvStructure->getSubField("values");
if(pvField==0) return false;
@@ -30,100 +29,76 @@ bool NTNameValue::isNTNameValue(PVStructurePtr pvStructure)
return true;
}
PVStructure::shared_pointer NTNameValue::create(
NTNameValuePtr NTNameValue::create(
bool hasFunction,bool hasTimeStamp, bool hasAlarm)
{
StandardField *standardField = getStandardField();
int nfields = 2;
StandardFieldPtr standardField = getStandardField();
size_t nfields = 2;
if(hasFunction) nfields++;
if(hasTimeStamp) nfields++;
if(hasAlarm) nfields++;
FieldCreate *fieldCreate = getFieldCreate();
PVDataCreate *pvDataCreate = getPVDataCreate();
FieldConstPtrArray fields = new FieldConstPtr[nfields];
fields[0] = fieldCreate->createScalarArray("names",pvString);
fields[1] = fieldCreate->createScalarArray("values",pvString);
FieldCreatePtr fieldCreate = getFieldCreate();
PVDataCreatePtr pvDataCreate = getPVDataCreate();
FieldConstPtrArray fields;
StringArray names;
fields.resize(nfields);
names.resize(nfields);
names[0] = "names";
fields[0] = fieldCreate->createScalarArray(pvString);
names[1] = "values";
fields[1] = fieldCreate->createScalarArray(pvString);
int ind = 2;
if(hasFunction) {
fields[ind++] = fieldCreate->createScalar(String("function"),pvString);
names[ind] = "function";
fields[ind++] = fieldCreate->createScalar(pvString);
}
if(hasTimeStamp) {
names[ind] = "timeStamp";
fields[ind++] = standardField->timeStamp();
}
if(hasAlarm) {
names[ind] = "alarm";
fields[ind++] = standardField->alarm();
}
return PVStructure::shared_pointer(
pvDataCreate->createPVStructure(0,"NTNameValue",ind,fields));
StructureConstPtr st = fieldCreate->createStructure(names,fields);
PVStructurePtr pvStructure = pvDataCreate->createPVStructure(st);
return NTNameValuePtr(new NTNameValue(pvStructure));
}
NTNameValue::NTNameValue(PVStructure::shared_pointer const & pvStructure)
: pvNTNameValue(pvStructure),
pvFunction(0),
pvTimeStamp(0),
pvAlarm(0),
pvNames(0),
pvValues(0)
: pvNTNameValue(pvStructure)
{
NTField *ntfield = NTField::get();
String name = pvStructure->getField()->getFieldName();
if(name.compare("NTNameValue")!=0) {
throw std::invalid_argument(
"pvArgument does not have name NTNameValue");
}
PVArray * pvArray = pvStructure->getScalarArrayField("names",pvString);
if(pvArray==0) {
throw std::invalid_argument(
"pvArgument does not have a string array field names");
}
pvNames = static_cast<PVStringArray *>(pvArray);
NTFieldPtr ntfield = NTField::get();
PVScalarArrayPtr pvArray =
pvStructure->getScalarArrayField("names",pvString);
pvNames = static_pointer_cast<PVStringArray>(pvArray);
pvArray = pvStructure->getScalarArrayField("values",pvString);
if(pvArray==0) {
throw std::invalid_argument(
"pvArgument does not have a string array field values");
}
pvValues = static_cast<PVStringArray *>(pvArray);
pvValues = static_pointer_cast<PVStringArray>(pvArray);
PVFieldPtr pvField = pvStructure->getSubField("function");
if(pvField!=0) {
if(pvField.get()!=NULL) {
pvFunction = pvStructure->getStringField("function");
}
pvField = pvStructure->getSubField("timeStamp");
if(pvField!=0 && ntfield->isTimeStamp(pvField->getField())) {
pvTimeStamp = static_cast<PVStructure *>(pvField);
if(pvField.get()!=NULL && ntfield->isTimeStamp(pvField->getField())) {
pvTimeStamp = static_pointer_cast<PVStructure>(pvField);
}
pvField = pvStructure->getSubField("alarm");
if(pvField!=0 && ntfield->isAlarm(pvField->getField())) {
pvAlarm = static_cast<PVStructure *>(pvField);
if(pvField.get()!=NULL && ntfield->isAlarm(pvField->getField())) {
pvAlarm = static_pointer_cast<PVStructure>(pvField);
}
}
NTNameValue::~NTNameValue()
void NTNameValue::attachTimeStamp(PVTimeStamp &pv)
{
if(pvTimeStamp.get()==NULL) return;
pv.attach(pvTimeStamp);
}
PVString * NTNameValue::getFunction()
void NTNameValue::attachAlarm(PVAlarm &pv)
{
return pvFunction;
}
void NTNameValue::attachTimeStamp(PVTimeStamp &pvTimeStamp)
{
if(this->pvTimeStamp==0) return;
pvTimeStamp.attach(this->pvTimeStamp);
}
void NTNameValue::attachAlarm(PVAlarm &pvAlarm)
{
if(this->pvAlarm==0) return;
pvAlarm.attach(this->pvAlarm);
}
PVStringArray * NTNameValue::getNames() {
return pvNames;
}
PVStringArray * NTNameValue::getValues() {
return pvValues;
if(pvAlarm.get()==NULL) return;
pv.attach(pvAlarm);
}
}}

27
src/nt/ntnameValue.h
View File

@@ -17,7 +17,7 @@ namespace epics { namespace pvData {
*
*/
class NTNameValue
class NTNameValue;
typedef std::tr1::shared_ptr<NTNameValue> NTNameValuePtr;
class NTNameValue
@@ -35,25 +35,19 @@ public:
* @param hasFunction Create a PVString field named function.
* @param hasTimeStamp Create a timeStamp structure field.
* @param hasAlarm Create an alarm structure field.
* @return a NTNameValue pvStructure.
* @return NTNameValuePtr
*/
static PVStructurePtr create(
static NTNameValuePtr create(
bool hasFunction,bool hasTimeStamp, bool hasAlarm);
/**
* Constructor
* @param pvStructure The pvStructure to which to attach.
* @return A NTNameValue that is attached to the pvStructure
*/
NTNameValue(PVStructurePtr const & pvStructure);
/**
* Destructor
*/
~NTNameValue();
~NTNameValue() {}
/**
* Get the function field.
* @return The pvString or null if no function field.
*/
PVStringPtr getFunction();
PVStringPtr & getFunction() {return pvFunction;}
/**
* Attach a pvTimeStamp.
* @param pvTimeStamp The pvTimeStamp that will be attached.
@@ -70,28 +64,29 @@ public:
* Get the pvStructure.
* @return PVStructurePtr.
*/
PVStructurePtr getPVStructure(){return pvNTNameValue;}
PVStructurePtr & getPVStructure(){return pvNTNameValue;}
/**
* Get the timeStamp.
* @return PVStructurePtr which may be null.
*/
PVStructurePtr getTimeStamp(){return pvTimeStamp;}
PVStructurePtr & getTimeStamp(){return pvTimeStamp;}
/**
* Get the alarm.
* @return PVStructurePtr which may be null.
*/
PVStructurePtr getAlarm() {return pvAlarm;}
PVStructurePtr & getAlarm() {return pvAlarm;}
/**
* Get the string array on names.
* @return The array of names.
*/
PVStringArrayPtr getNames();
PVStringArrayPtr & getNames() {return pvNames;}
/**
* Get the string array on values.
* @return The array of values.
*/
PVStringArrayPtr getValues();
PVStringArrayPtr & getValues() {return pvValues;}
private:
NTNameValue(PVStructurePtr const & pvStructure);
PVStructurePtr pvNTNameValue;
PVStringPtr pvFunction;
PVStructurePtr pvTimeStamp;

143
src/nt/nttable.cpp
View File

@@ -9,25 +9,26 @@
namespace epics { namespace pvData {
bool NTTable::isNTTable(PVStructurePtr pvStructure)
using std::tr1::static_pointer_cast;
bool NTTable::isNTTable(PVStructurePtr const & pvStructure)
{
NTField *ntfield = NTField::get();
NTFieldPtr ntfield = NTField::get();
//StandardField *standardField = getStandardField();
String name = pvStructure->getField()->getFieldName();
if(name.compare("NTTable")!=0) return false;
PVStringArray *pvLabel = static_cast<PVStringArray *>
PVStringArrayPtr pvLabel = static_pointer_cast<PVStringArray>
(pvStructure->getScalarArrayField("label",pvString));
if(pvLabel==0) return false;
int nfields = pvLabel->getLength();
int nextra = 1; // label is 1 field
if(pvLabel.get()==NULL) return false;
size_t nfields = pvLabel->getLength();
size_t nextra = 1; // label is 1 field
PVFieldPtr pvField = pvStructure->getSubField("function");
if(pvField!=0 && pvStructure->getStringField("function")) nextra++;
if(pvField.get()!=NULL
&& pvStructure->getStringField("function").get()!=NULL) nextra++;
pvField = pvStructure->getSubField("timeStamp");
if(pvField!=0 && ntfield->isTimeStamp(pvField->getField())) {
nextra++;
}
pvField = pvStructure->getSubField("alarm");
if(pvField!=0 && ntfield->isAlarm(pvField->getField())) {
if(pvField.get()!=NULL && ntfield->isAlarm(pvField->getField())) {
nextra++;
}
if(nfields!=(pvStructure->getStructure()->getNumberFields()-nextra)) return false;
@@ -41,122 +42,104 @@ bool NTTable::isNTTable(PVStructurePtr pvStructure)
return true;
}
PVStructure::shared_pointer NTTable::create(
NTTablePtr NTTable::create(
bool hasFunction,bool hasTimeStamp, bool hasAlarm,
int numberValues,
FieldConstPtrArray valueFields)
StringArray const & valueNames,
FieldConstPtrArray const &valueFields)
{
StandardField *standardField = getStandardField();
int nfields = 1;
StandardFieldPtr standardField = getStandardField();
size_t nfields = 1;
if(hasFunction) nfields++;
if(hasTimeStamp) nfields++;
if(hasAlarm) nfields++;
nfields += numberValues;
FieldCreate *fieldCreate = getFieldCreate();
PVDataCreate *pvDataCreate = getPVDataCreate();
FieldConstPtrArray fields = new FieldConstPtr[nfields];
int ind = 0;
nfields += valueFields.size();
FieldCreatePtr fieldCreate = getFieldCreate();
PVDataCreatePtr pvDataCreate = getPVDataCreate();
FieldConstPtrArray fields;
StringArray names;
fields.resize(nfields);
names.resize(nfields);
size_t ind = 0;
if(hasFunction) {
fields[ind++] = fieldCreate->createScalar(String("function"),pvString);
names[ind] = "function";
fields[ind++] = fieldCreate->createScalar(pvString);
}
if(hasTimeStamp) {
names[ind] = "timeStamp";
fields[ind++] = standardField->timeStamp();
}
if(hasAlarm) {
names[ind] = "alarm";
fields[ind++] = standardField->alarm();
}
fields[ind++] = standardField->scalarArray("label",pvString);
for(int i=0; i<numberValues ; i++) fields[ind++] = valueFields[i];
PVStructure::shared_pointer pvStructure = PVStructure::shared_pointer(
pvDataCreate->createPVStructure(0,"NTTable",nfields,fields));
String label[numberValues];
for(int i=0; i<numberValues; i++) {
FieldConstPtr field = fields[nfields - numberValues +i];
label[i] = field->getFieldName();
names[ind] = "label";
fields[ind++] = fieldCreate->createScalarArray(pvString);
size_t numberValues = valueNames.size();
for(size_t i=0; i<numberValues ; i++) {
names[ind] = valueNames[i];
fields[ind++] = valueFields[i];
}
PVStringArray *pvLabel = static_cast<PVStringArray *>
StructureConstPtr st = fieldCreate->createStructure(names,fields);
PVStructurePtr pvStructure = pvDataCreate->createPVStructure(st);
PVStringArrayPtr pvLabel = static_pointer_cast<PVStringArray>
(pvStructure->getScalarArrayField("label",pvString));
pvLabel->put(0,numberValues,label,0);
return pvStructure;
pvLabel->put(0,numberValues,valueNames,0);
return NTTablePtr(new NTTable(pvStructure));
}
NTTable::NTTable(PVStructure::shared_pointer const & pvStructure)
NTTable::NTTable(PVStructurePtr const & pvStructure)
: pvNTTable(pvStructure),
pvFunction(0),
pvTimeStamp(0),
pvAlarm(0),
pvLabel(0),
offsetFields(1)
{
NTField *ntfield = NTField::get();
String name = pvStructure->getField()->getFieldName();
if(name.compare("NTTable")!=0) {
throw std::invalid_argument(
"pvArgument does not have name NTTable");
}
PVScalarArray * pvScalarArray
NTFieldPtr ntfield = NTField::get();
PVScalarArrayPtr pvScalarArray
= pvStructure->getScalarArrayField("label",pvString);
if(pvScalarArray==0) {
throw std::invalid_argument(
"pvArgument did not have a structureArray field value");
}
pvLabel = static_cast<PVStringArray *>(pvScalarArray);
pvLabel = static_pointer_cast<PVStringArray>(pvScalarArray);
PVFieldPtr pvField = pvStructure->getSubField("function");
if(pvField!=0) {
pvFunction = pvStructure->getStringField("function");
if(pvField.get()!=NULL) {
offsetFields++;
pvFunction = pvStructure->getStringField("function");
}
pvField = pvStructure->getSubField("timeStamp");
if(pvField!=0 && ntfield->isTimeStamp(pvField->getField())) {
pvTimeStamp = static_cast<PVStructure *>(pvField);
if(pvField.get()!=NULL && ntfield->isTimeStamp(pvField->getField())) {
offsetFields++;
pvTimeStamp = static_pointer_cast<PVStructure>(pvField);
}
pvField = pvStructure->getSubField("alarm");
if(pvField!=0 && ntfield->isAlarm(pvField->getField())) {
pvAlarm = static_cast<PVStructure *>(pvField);
if(pvField.get()!=NULL && ntfield->isAlarm(pvField->getField())) {
offsetFields++;
pvAlarm = static_pointer_cast<PVStructure>(pvField);
}
}
NTTable::~NTTable()
void NTTable::attachTimeStamp(PVTimeStamp &pv)
{
if(pvTimeStamp.get()==NULL) return;
pv.attach(pvTimeStamp);
}
PVString * NTTable::getFunction()
void NTTable::attachAlarm(PVAlarm &pv)
{
return pvFunction;
if(pvAlarm.get()==NULL) return;
pv.attach(pvAlarm);
}
void NTTable::attachTimeStamp(PVTimeStamp &pvTimeStamp)
{
if(this->pvTimeStamp==0) return;
pvTimeStamp.attach(this->pvTimeStamp);
}
void NTTable::attachAlarm(PVAlarm &pvAlarm)
{
if(this->pvAlarm==0) return;
pvAlarm.attach(this->pvAlarm);
}
PVStringArray * NTTable::getLabel()
{
return pvLabel;
}
int NTTable::getNumberValues()
size_t NTTable::getNumberValues()
{
return pvLabel->getLength();
}
FieldConstPtr NTTable::getField(int index)
FieldConstPtr & NTTable::getField(size_t index)
{
return pvNTTable->getStructure()->getFields()[index+offsetFields];
FieldConstPtrArray fields = pvNTTable->getStructure()->getFields();
return fields[index + offsetFields];
}
PVFieldPtr NTTable::getPVField(int index)
PVFieldPtr & NTTable::getPVField(size_t index)
{
return pvNTTable->getPVFields()[index+offsetFields];
PVFieldPtrArray pvFields = pvNTTable->getPVFields();
return pvFields[index+offsetFields];
}
}}

33
src/nt/nttable.h
View File

@@ -17,7 +17,7 @@ namespace epics { namespace pvData {
*
*/
class NTTable
class NTTable;
typedef std::tr1::shared_ptr<NTTable> NTTablePtr;
class NTTable
@@ -37,27 +37,21 @@ public:
* @param hasAlarm Create an alarm structure field.
* @param numberValues The number of fields that follow the label field.
* @param valueFields The fields that follow the label field.
* @return an NTTable pvStructure.
* @return an NTTablePtr
*/
static PVStructurePtr create(
static NTTablePtr create(
bool hasFunction,bool hasTimeStamp, bool hasAlarm,
size_t numberValues,
StringArray const & valueNames,
FieldConstPtrArray const &valueFields);
/**
* Constructor
* @param pvStructure The pvStructure to which to attach.
* @return A NTTable that is attached to the pvStructure
*/
NTTable(PVStructurePtr const & pvStructure);
/**
* Destructor
*/
~NTTable();
~NTTable() {}
/**
* Get the function field.
* @return The pvString or null if no function field.
*/
PVStringPtr getFunction();
PVStringPtr & getFunction() {return pvFunction;}
/**
* Attach a pvTimeStamp.
* @param pvTimeStamp The pvTimeStamp that will be attached.
@@ -74,40 +68,41 @@ public:
* Get the pvStructure.
* @return PVStructurePtr.
*/
PVStructurePtr getPVStructure(){return pvNTTable;}
PVStructurePtr & getPVStructure(){return pvNTTable;}
/**
* Get the timeStamp.
* @return PVStructurePtr which may be null.
*/
PVStructurePtr getTimeStamp(){return pvTimeStamp;}
PVStructurePtr & getTimeStamp(){return pvTimeStamp;}
/**
* Get the alarm.
* @return PVStructurePtr which may be null.
*/
PVStructurePtr getAlarm() {return pvAlarm;}
PVStructurePtr & getAlarm() {return pvAlarm;}
/**
* Get the label field.
* @return The pvStringArray for the label.
*/
PVStringArrayPtr getLabel();
PVStringArrayPtr & getLabel() {return pvLabel;}
/**
* Get the the number of fields that follow the label field.
* @return The number of fields.
*/
int getNumberValues();
size_t getNumberValues();
/**
* Get the Field for a field that follows the label field.
* @param index The index of the field desired.
* @return The FieldConstPtr for the field.
*/
FieldConstPtr getField(int index);
FieldConstPtr & getField(size_t index);
/**
* Get the PVField for a field that follows the label field.
* @param index The index of the field desired.
* @return The PVFieldPtr for the field.
*/
PVFieldPtr getPVField(int index);
PVFieldPtr & getPVField(size_t index);
private:
NTTable(PVStructurePtr const & pvStructure);
PVStructurePtr pvNTTable;
PVStringPtr pvFunction;
PVStructurePtr pvTimeStamp;

63
test/nt/ntfieldTest.cpp
View File

@@ -23,22 +23,19 @@
#include <pv/nt.h>
#include <epicsExit.h>
#include <pv/CDRMonitor.h>
using namespace epics::pvData;
static FieldCreate * fieldCreate = 0;
static PVDataCreate * pvDataCreate = 0;
static StandardField *standardField = 0;
static StandardPVField *standardPVField = 0;
static NTField *ntField = 0;
static PVNTField *pvntField = 0;
static String builder("");
static FieldCreatePtr fieldCreate = getFieldCreate();
static PVDataCreatePtr pvDataCreate = getPVDataCreate();
static StandardFieldPtr standardField = getStandardField();
static StandardPVFieldPtr standardPVField = getStandardPVField();
static NTFieldPtr ntField = NTField::get();
static PVNTFieldPtr pvntField = PVNTField::get();
static String builder;
static void testNTField(FILE * fd)
{
StructureConstPtr structureConstPtr = ntField->createEnumerated("value");
StructureConstPtr structureConstPtr = ntField->createEnumerated();
builder.clear();
structureConstPtr->toString(&builder);
fprintf(fd,"%s\n",builder.c_str());
@@ -75,17 +72,17 @@ static void testNTField(FILE * fd)
assert(ntField->isControl(structureConstPtr));
StructureArrayConstPtr structureArrayConstPtr
= ntField->createEnumeratedArray("value");
= ntField->createEnumeratedArray();
builder.clear();
structureArrayConstPtr->toString(&builder);
fprintf(fd,"%s\n",builder.c_str());
structureArrayConstPtr = ntField->createTimeStampArray("value");
structureArrayConstPtr = ntField->createTimeStampArray();
builder.clear();
structureArrayConstPtr->toString(&builder);
fprintf(fd,"%s\n",builder.c_str());
structureArrayConstPtr = ntField->createAlarmArray("value");
structureArrayConstPtr = ntField->createAlarmArray();
builder.clear();
structureArrayConstPtr->toString(&builder);
fprintf(fd,"%s\n",builder.c_str());
@@ -93,40 +90,44 @@ static void testNTField(FILE * fd)
static void testPVNTField(FILE * fd)
{
String choices[] = {"one","two","three"};
PVStructure::shared_pointer pvStructure = PVStructure::shared_pointer(
pvntField->createEnumerated(0,"enumerated",choices, 3));
StringArray choices;
choices.resize(3);
choices[0] = "one";
choices[1] = "two";
choices[2] = "three";
PVStructurePtr pvStructure = PVStructurePtr(
pvntField->createEnumerated(choices));
builder.clear();
pvStructure->toString(&builder);
fprintf(fd,"%s\n",builder.c_str());
assert(ntField->isEnumerated(pvStructure->getStructure()));
pvStructure = PVStructure::shared_pointer(pvntField->createTimeStamp(0));
pvStructure = PVStructurePtr(pvntField->createTimeStamp());
builder.clear();
pvStructure->toString(&builder);
fprintf(fd,"%s\n",builder.c_str());
assert(ntField->isTimeStamp(pvStructure->getStructure()));
pvStructure = PVStructure::shared_pointer(pvntField->createAlarm(0));
pvStructure = PVStructurePtr(pvntField->createAlarm());
builder.clear();
pvStructure->toString(&builder);
fprintf(fd,"%s\n",builder.c_str());
assert(ntField->isAlarm(pvStructure->getStructure()));
pvStructure = PVStructure::shared_pointer(pvntField->createDisplay(0));
pvStructure = PVStructurePtr(pvntField->createDisplay());
builder.clear();
pvStructure->toString(&builder);
fprintf(fd,"%s\n",builder.c_str());
assert(ntField->isDisplay(pvStructure->getStructure()));
pvStructure = PVStructure::shared_pointer(pvntField->createAlarmLimit(0));
pvStructure = PVStructurePtr(pvntField->createAlarmLimit());
builder.clear();
pvStructure->toString(&builder);
fprintf(fd,"%s\n",builder.c_str());
assert(ntField->isAlarmLimit(pvStructure->getStructure()));
PVStructureArray::shared_pointer pvStructureArray = PVStructureArray::shared_pointer(
pvntField->createEnumeratedArray(0,"enumArray"));
PVStructureArrayPtr pvStructureArray = PVStructureArrayPtr(
pvntField->createEnumeratedArray());
builder.clear();
pvStructureArray->toString(&builder);
fprintf(fd,"\n%s\n",builder.c_str());
@@ -134,8 +135,8 @@ static void testPVNTField(FILE * fd)
pvStructureArray->getStructureArray()->getStructure()->toString(&builder);
fprintf(fd,"%s\n",builder.c_str());
pvStructureArray = PVStructureArray::shared_pointer(
pvntField->createTimeStampArray(0,"timeStampArray"));
pvStructureArray = PVStructureArrayPtr(
pvntField->createTimeStampArray());
builder.clear();
pvStructureArray->toString(&builder);
fprintf(fd,"\n%s\n",builder.c_str());
@@ -143,8 +144,8 @@ static void testPVNTField(FILE * fd)
pvStructureArray->getStructureArray()->getStructure()->toString(&builder);
fprintf(fd,"%s\n",builder.c_str());
pvStructureArray = PVStructureArray::shared_pointer(
pvntField->createAlarmArray(0,"alarmArray"));
pvStructureArray = PVStructureArrayPtr(
pvntField->createAlarmArray());
builder.clear();
pvStructureArray->toString(&builder);
fprintf(fd,"\n%s\n",builder.c_str());
@@ -161,16 +162,8 @@ int main(int argc,char *argv[])
if(fileName!=0 && fileName[0]!=0) {
fd = fopen(fileName,"w+");
}
fieldCreate = getFieldCreate();
pvDataCreate = getPVDataCreate();
standardField = getStandardField();
standardPVField = getStandardPVField();
ntField = NTField::get();
pvntField = PVNTField::get();
testNTField(fd);
testPVNTField(fd);
epicsExitCallAtExits();
CDRMonitor::get().show(fd,true);
return(0);
}

47
test/nt/ntnameValueTest.cpp
View File

@@ -23,53 +23,53 @@
#include <pv/nt.h>
#include <epicsExit.h>
#include <pv/CDRMonitor.h>
using namespace epics::pvData;
static PVDataCreate * pvDataCreate = 0;
static NTField *ntField = 0;
static PVNTField *pvntField = 0;
static String builder("");
static PVDataCreatePtr pvDataCreate = getPVDataCreate();
static NTFieldPtr ntField = NTField::get();
static PVNTFieldPtr pvntField = PVNTField::get();
static String builder;
static void test(FILE * fd)
{
PVStructure::shared_pointer pvStructure = NTNameValue::create(true,true,true);
NTNameValuePtr ntNameValue = NTNameValue::create(true,true,true);
PVStructurePtr pvStructure = ntNameValue->getPVStructure();
builder.clear();
pvStructure->toString(&builder);
fprintf(fd,"%s\n",builder.c_str());
builder.clear();
pvStructure->getStructure()->toString(&builder);
fprintf(fd,"%s\n",builder.c_str());
NTNameValue ntNameValue(pvStructure);
PVStringArray *names = ntNameValue.getNames();
PVStringArray *values = ntNameValue.getValues();
int n = 2;
String name[] = {String("name 0"),String("name 1")};
String value[] = {String("value 0"),String("value 1")};
PVStringArrayPtr names = ntNameValue->getNames();
PVStringArrayPtr values = ntNameValue->getValues();
size_t n = 2;
StringArray name;
StringArray value;
name.resize(n);
value.resize(n);
name[0] = "name 0";
name[1] = "name 1";
value[0] = "value 0";
value[1] = "value 1";
names->put(0,n,name,0);
values->put(0,n,value,0);
PVString *function = ntNameValue.getFunction();
PVStringPtr function = ntNameValue->getFunction();
function->put("test");
PVAlarm pvAlarm;
ntNameValue.attachAlarm(pvAlarm);
ntNameValue->attachAlarm(pvAlarm);
Alarm alarm;
alarm.setMessage("test alarm");
alarm.setSeverity(majorAlarm);
alarm.setStatus(clientStatus);
pvAlarm.set(alarm);
PVTimeStamp pvTimeStamp;
ntNameValue.attachTimeStamp(pvTimeStamp);
ntNameValue->attachTimeStamp(pvTimeStamp);
TimeStamp timeStamp(1000,1000,10);
pvTimeStamp.set(timeStamp);
builder.clear();
pvStructure->toString(&builder);
fprintf(fd,"%s\n",builder.c_str());
assert(NTNameValue::isNTNameValue(pvStructure.get()));
NTNameValue::shared_pointer pntNameValue
= NTNameValue::shared_pointer(new NTNameValue(pvStructure));
assert(NTNameValue::isNTNameValue(pvStructure));
}
@@ -81,12 +81,7 @@ int main(int argc,char *argv[])
if(fileName!=0 && fileName[0]!=0) {
fd = fopen(fileName,"w+");
}
pvDataCreate = getPVDataCreate();
ntField = NTField::get();
pvntField = PVNTField::get();
test(fd);
epicsExitCallAtExits();
CDRMonitor::get().show(fd,true);
return(0);
}

73
test/nt/nttableTest.cpp
View File

@@ -23,46 +23,46 @@
#include <pv/nt.h>
#include <epicsExit.h>
#include <pv/CDRMonitor.h>
using namespace epics::pvData;
using std::tr1::static_pointer_cast;
static FieldCreate * fieldCreate = 0;
static PVDataCreate * pvDataCreate = 0;
static NTField *ntField = 0;
static PVNTField *pvntField = 0;
static String builder("");
static FieldCreatePtr fieldCreate = getFieldCreate();
static PVDataCreatePtr pvDataCreate = getPVDataCreate();
static NTFieldPtr ntField = NTField::get();
static PVNTFieldPtr pvntField = PVNTField::get();
static String builder;
static void test(FILE * fd)
{
int n = 2;
FieldConstPtr fields[2];
fields[0] = fieldCreate->createScalarArray("position",pvDouble);
fields[1] = ntField->createAlarmArray("alarms");
PVStructure::shared_pointer pvStructure = NTTable::create(
true,true,true,n,fields);
size_t n = 2;
FieldConstPtrArray fields(n);
StringArray names(n);
names[0] = "position";
names[1] = "alarms";
fields[0] = fieldCreate->createScalarArray(pvDouble);
fields[1] = ntField->createAlarmArray();
NTTablePtr ntTable = NTTable::create(
true,true,true,names,fields);
PVStructurePtr pvStructure = ntTable->getPVStructure();
builder.clear();
pvStructure->toString(&builder);
fprintf(fd,"%s\n",builder.c_str());
builder.clear();
pvStructure->getStructure()->toString(&builder);
fprintf(fd,"%s\n",builder.c_str());
NTTable ntTable(pvStructure);
PVDoubleArray *pvPositions
= static_cast<PVDoubleArray *>(ntTable.getPVField(0));
double positions[2];
PVDoubleArrayPtr pvPositions
= static_pointer_cast<PVDoubleArray>(ntTable->getPVField(0));
DoubleArray positions(2);
positions[0] = 1.0;
positions[1] = 2.0;
pvPositions->put(0,n,positions,0);
PVStructureArray *pvAlarms
= static_cast<PVStructureArray *>(ntTable.getPVField(1));
pvPositions->put(0,2,positions,0);
PVStructureArrayPtr pvAlarms
= static_pointer_cast<PVStructureArray>(ntTable->getPVField(1));
PVAlarm pvAlarm;
Alarm alarm;
PVStructurePtr palarms[n];
for(int i=0; i<n; i++) {
palarms[i] = pvntField->createAlarm(0);
PVStructurePtrArray palarms(n);
for(size_t i=0; i<n; i++) {
palarms[i] = pvntField->createAlarm();
pvAlarm.attach(palarms[i]);
alarm.setMessage("test");
alarm.setSeverity(majorAlarm);
@@ -70,27 +70,26 @@ static void test(FILE * fd)
pvAlarm.set(alarm);
}
pvAlarms->put(0,n,palarms,0);
String labels[n];
labels[0] = pvPositions->getField()->getFieldName();
labels[1] = pvAlarms->getField()->getFieldName();
PVStringArray *label = ntTable.getLabel();
StringArray labels(n);
labels[0] = pvPositions->getFieldName();
labels[1] = pvAlarms->getFieldName();
PVStringArrayPtr label = ntTable->getLabel();
label->put(0,n,labels,0);
PVString *function = ntTable.getFunction();
PVStringPtr function = ntTable->getFunction();
function->put("test");
ntTable.attachAlarm(pvAlarm);
ntTable->attachAlarm(pvAlarm);
alarm.setMessage("test alarm");
alarm.setSeverity(majorAlarm);
alarm.setStatus(clientStatus);
pvAlarm.set(alarm);
PVTimeStamp pvTimeStamp;
ntTable.attachTimeStamp(pvTimeStamp);
ntTable->attachTimeStamp(pvTimeStamp);
TimeStamp timeStamp(1000,1000,10);
pvTimeStamp.set(timeStamp);
builder.clear();
pvStructure->toString(&builder);
fprintf(fd,"%s\n",builder.c_str());
assert(NTTable::isNTTable(pvStructure.get()));
assert(NTTable::isNTTable(pvStructure));
}
@@ -102,13 +101,7 @@ int main(int argc,char *argv[])
if(fileName!=0 && fileName[0]!=0) {
fd = fopen(fileName,"w+");
}
fieldCreate = getFieldCreate();
pvDataCreate = getPVDataCreate();
ntField = NTField::get();
pvntField = PVNTField::get();
test(fd);
epicsExitCallAtExits();
CDRMonitor::get().show(fd,true);
return(0);
}