From 0f251f5eb14d7eb759a6f868e89b78dd0ddd0792 Mon Sep 17 00:00:00 2001 From: Marty Kraimer Date: Thu, 2 Aug 2012 09:47:19 -0400 Subject: [PATCH] builds and tests work. must still look carefully --- src/nt/ntfield.cpp | 2 +- src/nt/ntnameValue.cpp | 109 +++++++++++---------------- src/nt/ntnameValue.h | 27 +++---- src/nt/nttable.cpp | 143 ++++++++++++++++-------------------- src/nt/nttable.h | 33 ++++----- test/nt/ntfieldTest.cpp | 63 +++++++--------- test/nt/ntnameValueTest.cpp | 47 ++++++------ test/nt/nttableTest.cpp | 73 +++++++++--------- 8 files changed, 213 insertions(+), 284 deletions(-) diff --git a/src/nt/ntfield.cpp b/src/nt/ntfield.cpp index 526d694..0b65e3c 100644 --- a/src/nt/ntfield.cpp +++ b/src/nt/ntfield.cpp @@ -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(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; diff --git a/src/nt/ntnameValue.cpp b/src/nt/ntnameValue.cpp index d9597e9..0dd3d9d 100644 --- a/src/nt/ntnameValue.cpp +++ b/src/nt/ntnameValue.cpp @@ -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(field); + ScalarArrayConstPtr pscalarArray = + static_pointer_cast(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(pvArray); + NTFieldPtr ntfield = NTField::get(); + PVScalarArrayPtr pvArray = + pvStructure->getScalarArrayField("names",pvString); + pvNames = static_pointer_cast(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(pvArray); + pvValues = static_pointer_cast(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(pvField); + if(pvField.get()!=NULL && ntfield->isTimeStamp(pvField->getField())) { + pvTimeStamp = static_pointer_cast(pvField); } pvField = pvStructure->getSubField("alarm"); - if(pvField!=0 && ntfield->isAlarm(pvField->getField())) { - pvAlarm = static_cast(pvField); + if(pvField.get()!=NULL && ntfield->isAlarm(pvField->getField())) { + pvAlarm = static_pointer_cast(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); } }} diff --git a/src/nt/ntnameValue.h b/src/nt/ntnameValue.h index c4256d3..875bffe 100644 --- a/src/nt/ntnameValue.h +++ b/src/nt/ntnameValue.h @@ -17,7 +17,7 @@ namespace epics { namespace pvData { * */ -class NTNameValue +class NTNameValue; typedef std::tr1::shared_ptr 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; diff --git a/src/nt/nttable.cpp b/src/nt/nttable.cpp index c91f2be..01dfa9d 100644 --- a/src/nt/nttable.cpp +++ b/src/nt/nttable.cpp @@ -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 + PVStringArrayPtr pvLabel = static_pointer_cast (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; icreatePVStructure(0,"NTTable",nfields,fields)); - String label[numberValues]; - for(int i=0; igetFieldName(); + names[ind] = "label"; + fields[ind++] = fieldCreate->createScalarArray(pvString); + size_t numberValues = valueNames.size(); + for(size_t i=0; i + StructureConstPtr st = fieldCreate->createStructure(names,fields); + PVStructurePtr pvStructure = pvDataCreate->createPVStructure(st); + PVStringArrayPtr pvLabel = static_pointer_cast (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(pvScalarArray); + pvLabel = static_pointer_cast(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(pvField); + if(pvField.get()!=NULL && ntfield->isTimeStamp(pvField->getField())) { offsetFields++; + pvTimeStamp = static_pointer_cast(pvField); } pvField = pvStructure->getSubField("alarm"); - if(pvField!=0 && ntfield->isAlarm(pvField->getField())) { - pvAlarm = static_cast(pvField); + if(pvField.get()!=NULL && ntfield->isAlarm(pvField->getField())) { offsetFields++; + pvAlarm = static_pointer_cast(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]; } }} diff --git a/src/nt/nttable.h b/src/nt/nttable.h index dd7e54f..72bb819 100644 --- a/src/nt/nttable.h +++ b/src/nt/nttable.h @@ -17,7 +17,7 @@ namespace epics { namespace pvData { * */ -class NTTable +class NTTable; typedef std::tr1::shared_ptr 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; diff --git a/test/nt/ntfieldTest.cpp b/test/nt/ntfieldTest.cpp index 214d644..1c9e150 100644 --- a/test/nt/ntfieldTest.cpp +++ b/test/nt/ntfieldTest.cpp @@ -23,22 +23,19 @@ #include -#include -#include - 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); } diff --git a/test/nt/ntnameValueTest.cpp b/test/nt/ntnameValueTest.cpp index d7cd916..05904f0 100644 --- a/test/nt/ntnameValueTest.cpp +++ b/test/nt/ntnameValueTest.cpp @@ -23,53 +23,53 @@ #include -#include -#include - 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); } diff --git a/test/nt/nttableTest.cpp b/test/nt/nttableTest.cpp index d21f666..8df9cd4 100644 --- a/test/nt/nttableTest.cpp +++ b/test/nt/nttableTest.cpp @@ -23,46 +23,46 @@ #include -#include -#include - 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(ntTable.getPVField(0)); - double positions[2]; + PVDoubleArrayPtr pvPositions + = static_pointer_cast(ntTable->getPVField(0)); + DoubleArray positions(2); positions[0] = 1.0; positions[1] = 2.0; - pvPositions->put(0,n,positions,0); - PVStructureArray *pvAlarms - = static_cast(ntTable.getPVField(1)); + pvPositions->put(0,2,positions,0); + PVStructureArrayPtr pvAlarms + = static_pointer_cast(ntTable->getPVField(1)); PVAlarm pvAlarm; Alarm alarm; - PVStructurePtr palarms[n]; - for(int i=0; icreateAlarm(0); + PVStructurePtrArray palarms(n); + for(size_t i=0; icreateAlarm(); 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); }