diff --git a/QtC-pvData.creator.user b/QtC-pvData.creator.user new file mode 100644 index 0000000..78fabf0 --- /dev/null +++ b/QtC-pvData.creator.user @@ -0,0 +1,66 @@ + + + + GenericProjectManager.GenericProject.Toolchain + 0 + + + ProjectExplorer.Project.ActiveTarget + 0 + + + ProjectExplorer.Project.EditorSettings + + System + + + + ProjectExplorer.Project.Target.0 + + Desktop + GenericProjectManager.GenericTarget + 0 + 0 + + /home/mrk/hgwork/pvDataCPP + + + all + + + + Make + GenericProjectManager.GenericMakeStep + + 1 + 0 + false + + all + GenericProjectManager.GenericBuildConfiguration + + 1 + + + 2 + /home/mrk/hgwork/pvDataCPP/bin/linux-x86/testIntrospect + false + + testIntrospect + true + $BUILDDIR + testIntrospect + ProjectExplorer.CustomExecutableRunConfiguration + + 1 + + + + ProjectExplorer.Project.TargetCount + 1 + + + ProjectExplorer.Project.Updater.FileVersion + 4 + + diff --git a/QtC-pvData.files b/QtC-pvData.files index 9feb805..0947af9 100644 --- a/QtC-pvData.files +++ b/QtC-pvData.files @@ -82,3 +82,4 @@ pvDataApp/test/testBitSet.cpp pvDataApp/test/testBaseException.cpp pvDataApp/misc/serializeHelper.h pvDataApp/misc/serializeHelper.cpp +pvDataApp/pvTest/testIntrospect.cpp diff --git a/pvDataApp/Makefile b/pvDataApp/Makefile index aeb282b..aa7a8b7 100644 --- a/pvDataApp/Makefile +++ b/pvDataApp/Makefile @@ -4,5 +4,6 @@ DIRS += misc DIRS += pv DIRS += factory DIRS += test +DIRS += pvTest include $(TOP)/configure/RULES_DIRS diff --git a/pvDataApp/factory/Makefile b/pvDataApp/factory/Makefile index b403318..259c822 100644 --- a/pvDataApp/factory/Makefile +++ b/pvDataApp/factory/Makefile @@ -32,6 +32,7 @@ LIBSRCS += FieldCreateFactory.cpp LIBSRCS += PVDataCreateFactory.cpp LIBSRCS += Convert.cpp LIBSRCS += StandardField.cpp +LIBSRCS += StandardPVField.cpp LIBRARY=pvFactory diff --git a/pvDataApp/factory/StandardField.cpp b/pvDataApp/factory/StandardField.cpp index 6ae349f..1af2372 100644 --- a/pvDataApp/factory/StandardField.cpp +++ b/pvDataApp/factory/StandardField.cpp @@ -1,70 +1,457 @@ /* StandardField.cpp */ #include +#include #include #include #include "pvIntrospect.h" -#include "pvData.h" -#include "convert.h" #include "standardField.h" namespace epics { namespace pvData { static String notImplemented("not implemented"); static FieldCreate* fieldCreate = 0; -static PVDataCreate* pvDataCreate = 0; +static StandardField* standardField = 0; +static String valueFieldName("value"); + +// following are preallocated structures + +static StructureConstPtr alarmField = 0; +static StructureConstPtr timeStampField = 0; +static StructureConstPtr displayField = 0; +static StructureConstPtr controlField = 0; +static StructureConstPtr booleanAlarmField = 0; +static StructureConstPtr byteAlarmField = 0; +static StructureConstPtr shortAlarmField = 0; +static StructureConstPtr intAlarmField = 0; +static StructureConstPtr longAlarmField = 0; +static StructureConstPtr floatAlarmField = 0; +static StructureConstPtr doubleAlarmField = 0; +static StructureConstPtr enumeratedAlarmField = 0; + +static void createAlarm() { + FieldConstPtrArray fields = new FieldConstPtr[2]; + fields[0] = fieldCreate->createScalar(String("severity"),pvInt); + fields[1] = fieldCreate->createScalar(String("message"),pvString); + alarmField = fieldCreate->createStructure(String("alarm"),2,fields); +} + +static void createTimeStamp() { + FieldConstPtrArray fields = new FieldConstPtr[2]; + fields[0] = fieldCreate->createScalar(String("secondsPastEpoch"),pvLong); + fields[1] = fieldCreate->createScalar(String("nanoSeconds"),pvInt); + timeStampField = fieldCreate->createStructure(String("timeStamp"),2,fields); +} + +static void createDisplay() { + FieldConstPtrArray limitFields = new FieldConstPtr[2]; + limitFields[0] = fieldCreate->createScalar(String("low"),pvDouble); + limitFields[1] = fieldCreate->createScalar(String("high"),pvDouble); + FieldConstPtrArray fields = new FieldConstPtr[4]; + fields[0] = fieldCreate->createScalar(String("description"),pvString); + fields[1] = fieldCreate->createScalar(String("format"),pvString); + fields[2] = fieldCreate->createScalar(String("units"),pvString); + fields[3] = fieldCreate->createStructure(String("limit"),2,limitFields); + displayField = fieldCreate->createStructure(String("display"),4,fields); +} + +static void createControl() { + FieldConstPtrArray limitFields = new FieldConstPtr[2]; + limitFields[0] = fieldCreate->createScalar(String("low"),pvDouble); + limitFields[1] = fieldCreate->createScalar(String("high"),pvDouble); + FieldConstPtrArray fields = new FieldConstPtr[2]; + fields[0] = fieldCreate->createStructure(String("limit"),2,limitFields); + fields[1] = fieldCreate->createScalar(String("minStep"),pvDouble); + controlField = fieldCreate->createStructure(String("control"),2,fields); +} + +static void createBooleanAlarm() { + FieldConstPtrArray fields = new FieldConstPtr[4]; + fields[0] = fieldCreate->createScalar(String("active"),pvBoolean); + fields[1] = fieldCreate->createScalar(String("falseSeverity"),pvInt); + fields[2] = fieldCreate->createScalar(String("trueSeverity"),pvInt); + fields[3] = fieldCreate->createScalar(String("changeStateSeverity"),pvInt); + booleanAlarmField = fieldCreate->createStructure(String("valueAlarm"),4,fields); +} + +static void createByteAlarm() { + int numFields = 10; + FieldConstPtrArray fields = new FieldConstPtr[numFields]; + fields[0] = fieldCreate->createScalar(String("active"),pvBoolean); + fields[1] = fieldCreate->createScalar(String("lowAlarmLimit"),pvByte); + fields[2] = fieldCreate->createScalar(String("lowWarningLimit"),pvByte); + fields[3] = fieldCreate->createScalar(String("highWarningLimit"),pvByte); + fields[4] = fieldCreate->createScalar(String("highAlarmLimit"),pvByte); + fields[5] = fieldCreate->createScalar(String("lowAlarmSeverity"),pvInt); + fields[6] = fieldCreate->createScalar(String("lowWarningSeverity"),pvInt); + fields[7] = fieldCreate->createScalar(String("highWarningSeverity"),pvInt); + fields[8] = fieldCreate->createScalar(String("highAlarmSeverity"),pvInt); + fields[9] = fieldCreate->createScalar(String("hystersis"),pvByte); + byteAlarmField = fieldCreate->createStructure(String("valueAlarm"),numFields,fields); +} + +static void createShortAlarm() { + int numFields = 10; + FieldConstPtrArray fields = new FieldConstPtr[numFields]; + fields[0] = fieldCreate->createScalar(String("active"),pvBoolean); + fields[1] = fieldCreate->createScalar(String("lowAlarmLimit"),pvShort); + fields[2] = fieldCreate->createScalar(String("lowWarningLimit"),pvShort); + fields[3] = fieldCreate->createScalar(String("highWarningLimit"),pvShort); + fields[4] = fieldCreate->createScalar(String("highAlarmLimit"),pvShort); + fields[5] = fieldCreate->createScalar(String("lowAlarmSeverity"),pvInt); + fields[6] = fieldCreate->createScalar(String("lowWarningSeverity"),pvInt); + fields[7] = fieldCreate->createScalar(String("highWarningSeverity"),pvInt); + fields[8] = fieldCreate->createScalar(String("highAlarmSeverity"),pvInt); + fields[9] = fieldCreate->createScalar(String("hystersis"),pvShort); + shortAlarmField = fieldCreate->createStructure(String("valueAlarm"),numFields,fields); +} + +static void createIntAlarm() { + int numFields = 10; + FieldConstPtrArray fields = new FieldConstPtr[numFields]; + fields[0] = fieldCreate->createScalar(String("active"),pvBoolean); + fields[1] = fieldCreate->createScalar(String("lowAlarmLimit"),pvInt); + fields[2] = fieldCreate->createScalar(String("lowWarningLimit"),pvInt); + fields[3] = fieldCreate->createScalar(String("highWarningLimit"),pvInt); + fields[4] = fieldCreate->createScalar(String("highAlarmLimit"),pvInt); + fields[5] = fieldCreate->createScalar(String("lowAlarmSeverity"),pvInt); + fields[6] = fieldCreate->createScalar(String("lowWarningSeverity"),pvInt); + fields[7] = fieldCreate->createScalar(String("highWarningSeverity"),pvInt); + fields[8] = fieldCreate->createScalar(String("highAlarmSeverity"),pvInt); + fields[9] = fieldCreate->createScalar(String("hystersis"),pvInt); + intAlarmField = fieldCreate->createStructure(String("valueAlarm"),numFields,fields); +} + +static void createLongAlarm() { + int numFields = 10; + FieldConstPtrArray fields = new FieldConstPtr[numFields]; + fields[0] = fieldCreate->createScalar(String("active"),pvBoolean); + fields[1] = fieldCreate->createScalar(String("lowAlarmLimit"),pvLong); + fields[2] = fieldCreate->createScalar(String("lowWarningLimit"),pvLong); + fields[3] = fieldCreate->createScalar(String("highWarningLimit"),pvLong); + fields[4] = fieldCreate->createScalar(String("highAlarmLimit"),pvLong); + fields[5] = fieldCreate->createScalar(String("lowAlarmSeverity"),pvInt); + fields[6] = fieldCreate->createScalar(String("lowWarningSeverity"),pvInt); + fields[7] = fieldCreate->createScalar(String("highWarningSeverity"),pvInt); + fields[8] = fieldCreate->createScalar(String("highAlarmSeverity"),pvInt); + fields[9] = fieldCreate->createScalar(String("hystersis"),pvLong); + longAlarmField = fieldCreate->createStructure(String("valueAlarm"),numFields,fields); +} + +static void createFloatAlarm() { + int numFields = 10; + FieldConstPtrArray fields = new FieldConstPtr[numFields]; + fields[0] = fieldCreate->createScalar(String("active"),pvBoolean); + fields[1] = fieldCreate->createScalar(String("lowAlarmLimit"),pvFloat); + fields[2] = fieldCreate->createScalar(String("lowWarningLimit"),pvFloat); + fields[3] = fieldCreate->createScalar(String("highWarningLimit"),pvFloat); + fields[4] = fieldCreate->createScalar(String("highAlarmLimit"),pvFloat); + fields[5] = fieldCreate->createScalar(String("lowAlarmSeverity"),pvInt); + fields[6] = fieldCreate->createScalar(String("lowWarningSeverity"),pvInt); + fields[7] = fieldCreate->createScalar(String("highWarningSeverity"),pvInt); + fields[8] = fieldCreate->createScalar(String("highAlarmSeverity"),pvInt); + fields[9] = fieldCreate->createScalar(String("hystersis"),pvFloat); + floatAlarmField = fieldCreate->createStructure(String("valueAlarm"),numFields,fields); +} + +static void createDoubleAlarm() { + int numFields = 10; + FieldConstPtrArray fields = new FieldConstPtr[numFields]; + fields[0] = fieldCreate->createScalar(String("active"),pvBoolean); + fields[1] = fieldCreate->createScalar(String("lowAlarmLimit"),pvDouble); + fields[2] = fieldCreate->createScalar(String("lowWarningLimit"),pvDouble); + fields[3] = fieldCreate->createScalar(String("highWarningLimit"),pvDouble); + fields[4] = fieldCreate->createScalar(String("highAlarmLimit"),pvDouble); + fields[5] = fieldCreate->createScalar(String("lowAlarmSeverity"),pvInt); + fields[6] = fieldCreate->createScalar(String("lowWarningSeverity"),pvInt); + fields[7] = fieldCreate->createScalar(String("highWarningSeverity"),pvInt); + fields[8] = fieldCreate->createScalar(String("highAlarmSeverity"),pvInt); + fields[9] = fieldCreate->createScalar(String("hystersis"),pvDouble); + doubleAlarmField = fieldCreate->createStructure(String("valueAlarm"),numFields,fields); +} + +static void createEnumeratedAlarm() { + int numFields = 3; + FieldConstPtrArray fields = new FieldConstPtr[numFields]; + fields[0] = fieldCreate->createScalar(String("active"),pvBoolean); + fields[1] = fieldCreate->createScalar(String("stateSeverity"),pvInt); + fields[2] = fieldCreate->createScalar(String("changeStateSeverity"),pvInt); + enumeratedAlarmField = fieldCreate->createStructure(String("valueAlarm"),numFields,fields); +} + +static void createPreAllocated() { + createAlarm(); + createTimeStamp(); + createDisplay(); + createControl(); + createBooleanAlarm(); + createByteAlarm(); + createShortAlarm(); + createIntAlarm(); + createLongAlarm(); + createFloatAlarm(); + createDoubleAlarm(); + createEnumeratedAlarm(); +} + + +static StructureConstPtr createProperties(String fieldName,FieldConstPtr field,String properties) { + bool gotAlarm = false; + bool gotTimeStamp = false; + bool gotDisplay = false; + bool gotControl = false; + bool gotValueAlarm = false; + int numProp = 0; + if(properties.find("alarm")!=String::npos) { gotAlarm = true; numProp++; } + if(properties.find("timeStamp")!=String::npos) { gotTimeStamp = true; numProp++; } + if(properties.find("display")!=String::npos) { gotDisplay = true; numProp++; } + if(properties.find("control")!=String::npos) { gotControl = true; numProp++; } + if(properties.find("valueAlarm")!=String::npos) { gotValueAlarm = true; numProp++; } + StructureConstPtr valueAlarm = 0; + Type type= field->getType(); + while(gotValueAlarm) { + if(type==scalar) { + ScalarConstPtr scalar = (ScalarConstPtr)field; + ScalarType scalarType = scalar->getScalarType(); + switch(scalarType) { + case pvBoolean: valueAlarm = booleanAlarmField; break; + case pvByte: valueAlarm = byteAlarmField; break; + case pvShort: valueAlarm = shortAlarmField; break; + case pvInt: valueAlarm = intAlarmField; break; + case pvLong: valueAlarm = longAlarmField; break; + case pvFloat: valueAlarm = floatAlarmField; break; + case pvDouble: valueAlarm = doubleAlarmField; break; + default: + throw std::logic_error(String("valueAlarm property for illegal type")); + } + break; + } + if(type==structure) { + StructureConstPtr structurePtr = (StructureConstPtr)field; + if(structurePtr->getNumberFields()==2) { + FieldConstPtrArray fields = structurePtr->getFields(); + FieldConstPtr first = fields[0]; + FieldConstPtr second = fields[1]; + String nameFirst = first->getFieldName(); + String nameSecond = second->getFieldName(); + int compareFirst = nameFirst.compare("index"); + int compareSecond = nameSecond.compare("choices"); + if(compareFirst==0 && compareSecond==0) { + if(first->getType()==scalar + && second->getType()==scalarArray) { + ScalarConstPtr scalarFirst = (ScalarConstPtr)first; + ScalarArrayConstPtr scalarArraySecond = + (ScalarArrayConstPtr)second; + if(scalarFirst->getScalarType()==pvInt + && scalarArraySecond->getElementType()==pvString) { + valueAlarm = enumeratedAlarmField; + break; + } + } + } + } + } + throw std::logic_error(String("valueAlarm property for illegal type")); + } + int numFields = numProp+1; + FieldConstPtrArray fields = new FieldConstPtr[numFields]; + int next = 0; + fields[next++] = field; + if(gotAlarm) fields[next++] = alarmField; + if(gotTimeStamp) fields[next++] = timeStampField; + if(gotDisplay) fields[next++] = displayField; + if(gotControl) fields[next++] = controlField; + if(gotValueAlarm) fields[next++] = valueAlarm; + return fieldCreate->createStructure(fieldName,numFields,fields); +} + StandardField::StandardField(){} StandardField::~StandardField(){} -PVScalar * StandardField::scalarValue(ScalarType scalarType) +ScalarConstPtr StandardField::scalar(String fieldName,ScalarType type) { - ScalarConstPtr scalar = fieldCreate->createScalar( - String("value"),scalarType); - return getPVDataCreate()->createPVScalar(0,scalar); + return fieldCreate->createScalar(fieldName,type); } -PVScalarArray * StandardField::scalarArrayValue(ScalarType elementType) +StructureConstPtr StandardField::scalar( + String fieldName,ScalarType type,String properties) { - ScalarArrayConstPtr scalarArray = fieldCreate->createScalarArray( - String("value"),elementType); - return pvDataCreate->createPVScalarArray(0,scalarArray); + ScalarConstPtr field = fieldCreate->createScalar(valueFieldName,type); + return createProperties(fieldName,field,properties); } -PVStructure * StandardField::scalarValue(ScalarType type,String properties) +ScalarArrayConstPtr StandardField::scalarArray( + String fieldName,ScalarType elementType) { - throw std::logic_error(notImplemented); + return fieldCreate->createScalarArray(fieldName,elementType); } -PVStructure * StandardField::scalarArrayValue(ScalarType elementType, - String properties) +StructureConstPtr StandardField::scalarArray( + String fieldName,ScalarType elementType, String properties) { - throw std::logic_error(notImplemented); + ScalarArrayConstPtr field = fieldCreate->createScalarArray( + valueFieldName,elementType); + return createProperties(fieldName,field,properties); } -PVStructure * StandardField::enumeratedValue(StringArray choices) +StructureArrayConstPtr StandardField::structureArray( + String fieldName,StructureConstPtr structure) { - throw std::logic_error(notImplemented); + return fieldCreate->createStructureArray(fieldName,structure); } -PVStructure * StandardField::enumeratedValue(StringArray choices, - String properties) +StructureConstPtr StandardField::structureArray( + String fieldName,StructureConstPtr structure,String properties) { - throw std::logic_error(notImplemented); + StructureArrayConstPtr field = fieldCreate->createStructureArray( + valueFieldName,structure); + return createProperties(fieldName,field,properties); } -PVStructure * StandardField::alarm() +StructureConstPtr StandardField::structure( + String fieldName,int numFields,FieldConstPtrArray fields) { - throw std::logic_error(notImplemented); + return fieldCreate->createStructure(fieldName,numFields,fields); } -PVStructure * StandardField::timeStamp() +StructureConstPtr StandardField::enumerated( + String fieldName,StringArray choices) { - throw std::logic_error(notImplemented); + FieldConstPtrArray fields = new FieldConstPtr[2]; + fields[0] = fieldCreate->createScalar(String("index"),pvInt); + fields[1] = fieldCreate->createScalarArray(String("choices"),pvString); + return fieldCreate->createStructure(fieldName,2,fields); } +StructureConstPtr StandardField::enumerated( + String fieldName,StringArray choices, String properties) +{ + StructureConstPtr field = standardField->enumerated(valueFieldName,choices); + return createProperties(fieldName,field,properties); +} + +ScalarConstPtr StandardField::scalarValue(ScalarType type) +{ + return fieldCreate->createScalar(valueFieldName,type); +} + +StructureConstPtr StandardField::scalarValue(ScalarType type,String properties) +{ + ScalarConstPtr field = fieldCreate->createScalar(valueFieldName,type); + return createProperties(valueFieldName,field,properties); +} + +ScalarArrayConstPtr StandardField::scalarArrayValue(ScalarType elementType) +{ + return fieldCreate->createScalarArray(valueFieldName,elementType); +} + +StructureConstPtr StandardField::scalarArrayValue( + ScalarType elementType, String properties) +{ + ScalarArrayConstPtr field = fieldCreate->createScalarArray( + valueFieldName,elementType); + return createProperties(valueFieldName,field,properties); + +} + +StructureArrayConstPtr StandardField::structureArrayValue( + StructureConstPtr structure) +{ + return fieldCreate->createStructureArray(valueFieldName,structure); +} + +StructureConstPtr StandardField::structureArrayValue( + StructureConstPtr structure,String properties) +{ + StructureArrayConstPtr field = fieldCreate->createStructureArray( + valueFieldName,structure); + return createProperties(valueFieldName,field,properties); + +} + +StructureConstPtr StandardField::structureValue( + int numFields,FieldConstPtrArray fields) +{ + return fieldCreate->createStructure(valueFieldName,numFields,fields); +} + +StructureConstPtr StandardField::enumeratedValue(StringArray choices) +{ + FieldConstPtrArray fields = new FieldConstPtr[2]; + fields[0] = fieldCreate->createScalar(String("index"),pvInt); + fields[1] = fieldCreate->createScalarArray(String("choices"),pvString); + return fieldCreate->createStructure(valueFieldName,2,fields); +} + +StructureConstPtr StandardField::enumeratedValue( + StringArray choices, String properties) +{ + StructureConstPtr field = standardField->enumerated(valueFieldName,choices); + return createProperties(valueFieldName,field,properties); +} + +StructureConstPtr StandardField::alarm() +{ + return alarmField; +} + +StructureConstPtr StandardField::timeStamp() +{ + return timeStampField; +} + +StructureConstPtr StandardField::display() +{ + return displayField; +} + +StructureConstPtr StandardField::control() +{ + return controlField; +} + +StructureConstPtr StandardField::booleanAlarm() +{ + return booleanAlarmField; +} + +StructureConstPtr StandardField::byteAlarm() +{ + return byteAlarmField; +} + +StructureConstPtr StandardField::shortAlarm() +{ + return shortAlarmField; +} + +StructureConstPtr StandardField::intAlarm() +{ + return intAlarmField; +} + +StructureConstPtr StandardField::longAlarm() +{ + return longAlarmField; +} + +StructureConstPtr StandardField::floatAlarm() +{ + return floatAlarmField; +} + +StructureConstPtr StandardField::doubleAlarm() +{ + return doubleAlarmField; +} + +StructureConstPtr StandardField::enumeratedAlarm() +{ + return enumeratedAlarmField; +} -static StandardField* instance = 0; class StandardFieldExt : public StandardField { @@ -76,12 +463,12 @@ StandardField * getStandardField() { static Mutex mutex = Mutex(); Lock xx(&mutex); - if(instance==0) { - instance = new StandardFieldExt(); + if(standardField==0) { + standardField = new StandardFieldExt(); fieldCreate = getFieldCreate(); - pvDataCreate = getPVDataCreate(); + createPreAllocated(); } - return instance; + return standardField; } }} diff --git a/pvDataApp/factory/StandardPVField.cpp b/pvDataApp/factory/StandardPVField.cpp new file mode 100644 index 0000000..4d8742f --- /dev/null +++ b/pvDataApp/factory/StandardPVField.cpp @@ -0,0 +1,213 @@ +/* StandardPVField.cpp */ +#include +#include +#include +#include "pvIntrospect.h" +#include "pvData.h" +#include "convert.h" +#include "standardField.h" +#include "standardPVField.h" + +namespace epics { namespace pvData { + +static String notImplemented("not implemented"); +static FieldCreate* fieldCreate = 0; +static PVDataCreate* pvDataCreate = 0; + +StandardPVField::StandardPVField(){} + +StandardPVField::~StandardPVField(){} + + +PVScalar * StandardPVField::scalar(String fieldName,ScalarType type) +{ + throw std::logic_error(notImplemented); +} + +PVStructure * StandardPVField::scalar(String fieldName,ScalarType type,String properties) +{ + throw std::logic_error(notImplemented); +} + +PVScalarArray * StandardPVField::scalarArray(String fieldName,ScalarType elementType) +{ + throw std::logic_error(notImplemented); +} + +PVStructure * StandardPVField::scalarArray(String fieldName,ScalarType elementType, String properties) +{ + throw std::logic_error(notImplemented); +} + +PVStructureArray * StandardPVField::structureArray(String fieldName,StructureConstPtr structure) +{ + throw std::logic_error(notImplemented); +} + +PVStructure * StandardPVField::structureArray(String fieldName,StructureConstPtr structure,String properties) +{ + throw std::logic_error(notImplemented); +} + +PVStructure *StandardPVField::structure(String fieldName,PVStructure *pvStructure) +{ + throw std::logic_error(notImplemented); +} + +PVStructure *StandardPVField::structure(String fieldName,PVStructure *pvStructure,String properties) +{ + throw std::logic_error(notImplemented); +} + +PVStructure * StandardPVField::enumerated(String fieldName,StringArray choices) +{ + throw std::logic_error(notImplemented); +} + +PVStructure * StandardPVField::enumerated(String fieldName,StringArray choices, String properties) +{ + throw std::logic_error(notImplemented); +} + +PVScalar * StandardPVField::scalarValue(ScalarType scalarType) +{ + ScalarConstPtr scalar = fieldCreate->createScalar( + String("value"),scalarType); + return getPVDataCreate()->createPVScalar(0,scalar); +} + +PVStructure * StandardPVField::scalarValue(ScalarType type,String properties) +{ + throw std::logic_error(notImplemented); +} + +PVScalarArray * StandardPVField::scalarArrayValue(ScalarType elementType) +{ + ScalarArrayConstPtr scalarArray = fieldCreate->createScalarArray( + String("value"),elementType); + return pvDataCreate->createPVScalarArray(0,scalarArray); +} + +PVStructure * StandardPVField::scalarArrayValue(ScalarType elementType, String properties) +{ + throw std::logic_error(notImplemented); +} + +PVStructureArray * StandardPVField::structureArrayValue(StructureConstPtr structure) +{ + throw std::logic_error(notImplemented); +} + +PVStructure * StandardPVField::structureArrayValue(StructureConstPtr structure,String properties) +{ + throw std::logic_error(notImplemented); +} + +PVStructure *StandardPVField::structureValue(PVStructure *pvStructure) +{ + throw std::logic_error(notImplemented); +} + +PVStructure *StandardPVField::structureValue(PVStructure *pvStructure,String properties) +{ + throw std::logic_error(notImplemented); +} + +PVStructure * StandardPVField::enumeratedValue(StringArray choices) +{ + throw std::logic_error(notImplemented); +} + +PVStructure * StandardPVField::enumeratedValue(StringArray choices, String properties) +{ + throw std::logic_error(notImplemented); +} + +PVStructure * StandardPVField::alarm() +{ + throw std::logic_error(notImplemented); +} + +PVStructure * StandardPVField::timeStamp() +{ + throw std::logic_error(notImplemented); +} + +PVStructure * StandardPVField::display() +{ + throw std::logic_error(notImplemented); +} + +PVStructure * StandardPVField::control() +{ + throw std::logic_error(notImplemented); +} + +PVStructure * StandardPVField::booleanAlarm() +{ + throw std::logic_error(notImplemented); +} + +PVStructure * StandardPVField::byteAlarm() +{ + throw std::logic_error(notImplemented); +} + +PVStructure * StandardPVField::shortAlarm() +{ + throw std::logic_error(notImplemented); +} + +PVStructure * StandardPVField::intAlarm() +{ + throw std::logic_error(notImplemented); +} + +PVStructure * StandardPVField::longAlarm() +{ + throw std::logic_error(notImplemented); +} + +PVStructure * StandardPVField::floatAlarm() +{ + throw std::logic_error(notImplemented); +} + +PVStructure * StandardPVField::doubleAlarm() +{ + throw std::logic_error(notImplemented); +} + +PVStructure * StandardPVField::enumeratedAlarm() +{ + throw std::logic_error(notImplemented); +} + +PVStructure * StandardPVField::powerSupply() +{ + throw std::logic_error(notImplemented); +} + + + +static StandardPVField* instance = 0; + + +class StandardPVFieldExt : public StandardPVField { +public: + StandardPVFieldExt(): StandardPVField(){}; +}; + +StandardPVField * getStandardPVField() { + static Mutex mutex = Mutex(); + Lock xx(&mutex); + + if(instance==0) { + instance = new StandardPVFieldExt(); + fieldCreate = getFieldCreate(); + pvDataCreate = getPVDataCreate(); + } + return instance; +} + +}} diff --git a/pvDataApp/pv/Makefile b/pvDataApp/pv/Makefile index 524b8fd..e993dc4 100644 --- a/pvDataApp/pv/Makefile +++ b/pvDataApp/pv/Makefile @@ -6,6 +6,7 @@ INC += pvIntrospect.h INC += pvData.h INC += convert.h INC += standardField.h +INC += standardPVField.h include $(TOP)/configure/RULES #---------------------------------------- diff --git a/pvDataApp/pv/standardField.h b/pvDataApp/pv/standardField.h index 65f05c0..c627776 100644 --- a/pvDataApp/pv/standardField.h +++ b/pvDataApp/pv/standardField.h @@ -4,7 +4,6 @@ #ifndef STANDARDFIELD_H #define STANDARDFIELD_H #include "pvIntrospect.h" -#include "pvData.h" namespace epics { namespace pvData { @@ -12,16 +11,36 @@ namespace epics { namespace pvData { public: StandardField(); ~StandardField(); - PVScalar * scalarValue(ScalarType type); - PVScalarArray * scalarArrayValue(ScalarType elementType); - PVStructure * scalarValue(ScalarType type,String properties); - PVStructure * scalarArrayValue(ScalarType elementType, - String properties); - PVStructure * enumeratedValue(StringArray choices); - PVStructure * enumeratedValue(StringArray choices, - String properties); - PVStructure * alarm(); - PVStructure * timeStamp(); + ScalarConstPtr scalar(String fieldName,ScalarType type); + StructureConstPtr scalar(String fieldName,ScalarType type,String properties); + ScalarArrayConstPtr scalarArray(String fieldName,ScalarType elementType); + StructureConstPtr scalarArray(String fieldName,ScalarType elementType, String properties); + StructureArrayConstPtr structureArray(String fieldName,StructureConstPtr structure); + StructureConstPtr structureArray(String fieldName,StructureConstPtr structure,String properties); + StructureConstPtr structure(String fieldName,int numFields,FieldConstPtrArray fields); + StructureConstPtr enumerated(String fieldName,StringArray choices); + StructureConstPtr enumerated(String fieldName,StringArray choices, String properties); + ScalarConstPtr scalarValue(ScalarType type); + StructureConstPtr scalarValue(ScalarType type,String properties); + ScalarArrayConstPtr scalarArrayValue(ScalarType elementType); + StructureConstPtr scalarArrayValue(ScalarType elementType, String properties); + StructureArrayConstPtr structureArrayValue(StructureConstPtr structure); + StructureConstPtr structureArrayValue(StructureConstPtr structure,String properties); + StructureConstPtr structureValue(int numFields,FieldConstPtrArray fields); + StructureConstPtr enumeratedValue(StringArray choices); + StructureConstPtr enumeratedValue(StringArray choices, String properties); + StructureConstPtr alarm(); + StructureConstPtr timeStamp(); + StructureConstPtr display(); + StructureConstPtr control(); + StructureConstPtr booleanAlarm(); + StructureConstPtr byteAlarm(); + StructureConstPtr shortAlarm(); + StructureConstPtr intAlarm(); + StructureConstPtr longAlarm(); + StructureConstPtr floatAlarm(); + StructureConstPtr doubleAlarm(); + StructureConstPtr enumeratedAlarm(); }; extern StandardField * getStandardField(); diff --git a/pvDataApp/pv/standardPVField.h b/pvDataApp/pv/standardPVField.h new file mode 100644 index 0000000..274538b --- /dev/null +++ b/pvDataApp/pv/standardPVField.h @@ -0,0 +1,53 @@ +/* standardPVField.h */ +#include +#include +#ifndef STANDARDPVFIELD_H +#define STANDARDPVFIELD_H +#include "pvIntrospect.h" +#include "pvData.h" + +namespace epics { namespace pvData { + + class StandardPVField : private NoDefaultMethods { + public: + StandardPVField(); + ~StandardPVField(); + PVScalar * scalar(String fieldName,ScalarType type); + PVStructure * scalar(String fieldName,ScalarType type,String properties); + PVScalarArray * scalarArray(String fieldName,ScalarType elementType); + PVStructure * scalarArray(String fieldName,ScalarType elementType, String properties); + PVStructureArray * structureArray(String fieldName,StructureConstPtr structure); + PVStructure * structureArray(String fieldName,StructureConstPtr structure,String properties); + PVStructure *structure(String fieldName,PVStructure *pvStructure); + PVStructure *structure(String fieldName,PVStructure *pvStructure,String properties); + PVStructure * enumerated(String fieldName,StringArray choices); + PVStructure * enumerated(String fieldName,StringArray choices, String properties); + PVScalar * scalarValue(ScalarType type); + PVStructure * scalarValue(ScalarType type,String properties); + PVScalarArray * scalarArrayValue(ScalarType elementType); + PVStructure * scalarArrayValue(ScalarType elementType, String properties); + PVStructureArray * structureArrayValue(StructureConstPtr structure); + PVStructure * structureArrayValue(StructureConstPtr structure,String properties); + PVStructure *structureValue(PVStructure *pvStructure); + PVStructure *structureValue(PVStructure *pvStructure,String properties); + PVStructure * enumeratedValue(StringArray choices); + PVStructure * enumeratedValue(StringArray choices, String properties); + PVStructure * alarm(); + PVStructure * timeStamp(); + PVStructure * display(); + PVStructure * control(); + PVStructure * booleanAlarm(); + PVStructure * byteAlarm(); + PVStructure * shortAlarm(); + PVStructure * intAlarm(); + PVStructure * longAlarm(); + PVStructure * floatAlarm(); + PVStructure * doubleAlarm(); + PVStructure * enumeratedAlarm(); + PVStructure * powerSupply(); + }; + + extern StandardPVField * getStandardPVField(); + +}} +#endif /* STANDARDPVFIELD_H */ diff --git a/pvDataApp/pvTest/Makefile b/pvDataApp/pvTest/Makefile new file mode 100644 index 0000000..85cc118 --- /dev/null +++ b/pvDataApp/pvTest/Makefile @@ -0,0 +1,12 @@ +TOP=../.. + +include $(TOP)/configure/CONFIG + +PROD_HOST += testIntrospect +testIntrospect_SRCS += testIntrospect.cpp +testIntrospect_LIBS += pvFactory + +include $(TOP)/configure/RULES +#---------------------------------------- +# ADD RULES AFTER THIS LINE + diff --git a/pvDataApp/pvTest/testIntrospect.cpp b/pvDataApp/pvTest/testIntrospect.cpp new file mode 100644 index 0000000..0630ed2 --- /dev/null +++ b/pvDataApp/pvTest/testIntrospect.cpp @@ -0,0 +1,44 @@ +/* testSimpleStructure.cpp */ +/* Author: Marty Kraimer Date: 2010.09 */ + +#include +#include +#include +#include +#include + +#include "requester.h" +#include "pvIntrospect.h" +#include "standardField.h" + +using namespace epics::pvData; + +static FieldCreate * fieldCreate = 0; +static StandardField *standardField = 0; +static String buffer(""); + + +void testSimpleStructure(FILE * fd) { + fprintf(fd,"\ntestSimpleStructure\n"); + String properties("alarm,timeStamp,display,control,valueAlarm"); + StructureConstPtr ptop = standardField->scalarValue(pvDouble,properties); + buffer.clear(); + ptop->toString(&buffer); + fprintf(fd,"%s\n",buffer.c_str()); +} + +int main(int argc,char *argv[]) +{ + char *fileName = 0; + if(argc>1) fileName = argv[1]; +printf("fileName %p\n",fileName); + FILE * fd = stdout; + if(fileName!=0 && fileName[0]!=0) { + fd = fopen(fileName,"w+"); + } + fieldCreate = getFieldCreate(); + standardField = getStandardField(); + testSimpleStructure(fd); + return(0); +} + diff --git a/pvDataApp/test/Makefile b/pvDataApp/test/Makefile index 61be128..cbfb658 100644 --- a/pvDataApp/test/Makefile +++ b/pvDataApp/test/Makefile @@ -6,6 +6,10 @@ PROD_HOST += testIntrospect testIntrospect_SRCS += testIntrospect.cpp testIntrospect_LIBS += pvFactory +PROD_HOST += testIntrospectScalar +testIntrospectScalar_SRCS += testIntrospectScalar.cpp +testIntrospectScalar_LIBS += pvFactory + PROD_HOST += testPVAuxInfo testPVAuxInfo_SRCS += testPVAuxInfo.cpp testPVAuxInfo_LIBS += pvFactory diff --git a/pvDataApp/test/testIntrospectScalar.cpp b/pvDataApp/test/testIntrospectScalar.cpp new file mode 100644 index 0000000..4d924b4 --- /dev/null +++ b/pvDataApp/test/testIntrospectScalar.cpp @@ -0,0 +1,24 @@ +/* testIntrospectScalar.cpp */ +/* Author: Marty Kraimer Date: 2010.10 */ + +#include +#include +#include +#include +#include + +#include "pvIntrospect.h" +#include "standardField.h" + +using namespace epics::pvData; + +int main(int argc,char *argv[]) +{ + StandardField *standardField = getStandardField(); + StructureConstPtr doubleValue = standardField->scalarValue( + pvDouble,String("alarm,timeStamp,display,control,doubleAlarm")); + String buffer(""); + doubleValue->toString(&buffer); + printf("doubleValue\n,%s\n",buffer.c_str()); + return(0); +} diff --git a/pvDataApp/test/testPVScalar.cpp b/pvDataApp/test/testPVScalar.cpp index 7246e8b..30ede7a 100644 --- a/pvDataApp/test/testPVScalar.cpp +++ b/pvDataApp/test/testPVScalar.cpp @@ -12,6 +12,7 @@ #include "pvIntrospect.h" #include "pvData.h" #include "standardField.h" +#include "standardPVField.h" using namespace epics::pvData; @@ -21,7 +22,7 @@ static String buffer(""); void testBoolean() { printf("\ntestBoolean\n"); - PVScalar *pvScalar = getStandardField()->scalarValue(pvBoolean); + PVScalar *pvScalar = getStandardPVField()->scalarValue(pvBoolean); PVBoolean *pvValue = (PVBoolean *)pvScalar; bool value = true; pvValue->put(value); @@ -57,7 +58,7 @@ void testBoolean() { pvValue->toString(&buffer); printf("%s\n",buffer.c_str()); pvScalar->message(String("this is a test message"),infoMessage); - PVScalar *other = getStandardField()->scalarValue(pvDouble); + PVScalar *other = getStandardPVField()->scalarValue(pvDouble); bool isEqual = pvScalar==other; printf("expect false isEqual %s\n",(isEqual ? "true" : "false")); delete pvValue; @@ -65,7 +66,7 @@ void testBoolean() { void testByte() { printf("\ntestByte\n"); - PVScalar *pvScalar = getStandardField()->scalarValue(pvByte); + PVScalar *pvScalar = getStandardPVField()->scalarValue(pvByte); PVByte *pvValue = (PVByte *)pvScalar; epicsInt8 value = 2; pvValue->put(value); @@ -97,7 +98,7 @@ void testByte() { pvValue->toString(&buffer); printf("%s\n",buffer.c_str()); pvScalar->message(String("this is a test message"),infoMessage); - PVScalar *other = getStandardField()->scalarValue(pvDouble); + PVScalar *other = getStandardPVField()->scalarValue(pvDouble); bool isEqual = pvScalar==other; printf("expect false isEqual %s\n",(isEqual ? "true" : "false")); delete pvValue; @@ -105,7 +106,7 @@ void testByte() { void testShort() { printf("\ntestShort\n"); - PVScalar *pvScalar = getStandardField()->scalarValue(pvShort); + PVScalar *pvScalar = getStandardPVField()->scalarValue(pvShort); PVShort *pvValue = (PVShort *)pvScalar; epicsInt16 value = 2; pvValue->put(value); @@ -137,7 +138,7 @@ void testShort() { pvValue->toString(&buffer); printf("%s\n",buffer.c_str()); pvScalar->message(String("this is a test message"),infoMessage); - PVScalar *other = getStandardField()->scalarValue(pvDouble); + PVScalar *other = getStandardPVField()->scalarValue(pvDouble); bool isEqual = pvScalar==other; printf("expect false isEqual %s\n",(isEqual ? "true" : "false")); delete pvValue; @@ -145,7 +146,7 @@ void testShort() { void testInt() { printf("\ntestInt\n"); - PVScalar *pvScalar = getStandardField()->scalarValue(pvInt); + PVScalar *pvScalar = getStandardPVField()->scalarValue(pvInt); PVInt *pvValue = (PVInt *)pvScalar; epicsInt32 value = 2; pvValue->put(value); @@ -177,7 +178,7 @@ void testInt() { pvValue->toString(&buffer); printf("%s\n",buffer.c_str()); pvScalar->message(String("this is a test message"),infoMessage); - PVScalar *other = getStandardField()->scalarValue(pvDouble); + PVScalar *other = getStandardPVField()->scalarValue(pvDouble); bool isEqual = pvScalar==other; printf("expect false isEqual %s\n",(isEqual ? "true" : "false")); delete pvValue; @@ -185,7 +186,7 @@ void testInt() { void testLong() { printf("\ntestLong\n"); - PVScalar *pvScalar = getStandardField()->scalarValue(pvLong); + PVScalar *pvScalar = getStandardPVField()->scalarValue(pvLong); PVLong *pvValue = (PVLong *)pvScalar; epicsInt64 value = 2; pvValue->put(value); @@ -217,7 +218,7 @@ void testLong() { pvValue->toString(&buffer); printf("%s\n",buffer.c_str()); pvScalar->message(String("this is a test message"),infoMessage); - PVScalar *other = getStandardField()->scalarValue(pvDouble); + PVScalar *other = getStandardPVField()->scalarValue(pvDouble); bool isEqual = pvScalar==other; printf("expect false isEqual %s\n",(isEqual ? "true" : "false")); delete pvValue; @@ -225,7 +226,7 @@ void testLong() { void testFloat() { printf("\ntestFloat\n"); - PVScalar *pvScalar = getStandardField()->scalarValue(pvFloat); + PVScalar *pvScalar = getStandardPVField()->scalarValue(pvFloat); PVFloat *pvValue = (PVFloat *)pvScalar; float value = 2; pvValue->put(value); @@ -264,7 +265,7 @@ void testFloat() { void testDouble() { printf("\ntestDouble\n"); - PVScalar *pvScalar = getStandardField()->scalarValue(pvDouble); + PVScalar *pvScalar = getStandardPVField()->scalarValue(pvDouble); PVDouble *pvValue = (PVDouble *)pvScalar; double value = 2; pvValue->put(value); @@ -303,7 +304,7 @@ void testDouble() { void testString() { printf("\ntestString\n"); - PVScalar *pvScalar = getStandardField()->scalarValue(pvString); + PVScalar *pvScalar = getStandardPVField()->scalarValue(pvString); PVString *pvValue = (PVString *)pvScalar; String value = "testString"; pvValue->put(value); diff --git a/pvDataApp/test/testPVScalarArray.cpp b/pvDataApp/test/testPVScalarArray.cpp index 38c1bab..d7841c2 100644 --- a/pvDataApp/test/testPVScalarArray.cpp +++ b/pvDataApp/test/testPVScalarArray.cpp @@ -11,6 +11,7 @@ #include "pvIntrospect.h" #include "pvData.h" #include "standardField.h" +#include "standardPVField.h" using namespace epics::pvData; @@ -21,7 +22,7 @@ static String buffer(""); void testBooleanArray() { printf("\ntestBooleanArray\n"); PVScalarArray *pvScalarArray = - getStandardField()->scalarArrayValue(pvBoolean); + getStandardPVField()->scalarArrayValue(pvBoolean); PVBooleanArray *pvValue = (PVBooleanArray *)pvScalarArray; int length = 5; bool *value = new bool[length]; @@ -51,7 +52,7 @@ void testBooleanArray() { void testByteArray() { printf("\ntestByteArray\n"); PVScalarArray *pvScalarArray = - getStandardField()->scalarArrayValue(pvByte); + getStandardPVField()->scalarArrayValue(pvByte); PVByteArray *pvValue = (PVByteArray *)pvScalarArray; int length = 5; epicsInt8 *value = new epicsInt8[length]; @@ -79,7 +80,7 @@ void testByteArray() { void testShortArray() { printf("\ntestShortArray\n"); PVScalarArray *pvScalarArray = - getStandardField()->scalarArrayValue(pvShort); + getStandardPVField()->scalarArrayValue(pvShort); PVShortArray *pvValue = (PVShortArray *)pvScalarArray; int length = 5; epicsInt16 *value = new epicsInt16[length]; @@ -107,7 +108,7 @@ void testShortArray() { void testIntArray() { printf("\ntestIntArray\n"); PVScalarArray *pvScalarArray = - getStandardField()->scalarArrayValue(pvInt); + getStandardPVField()->scalarArrayValue(pvInt); PVIntArray *pvValue = (PVIntArray *)pvScalarArray; int length = 5; epicsInt32 *value = new epicsInt32[length]; @@ -136,7 +137,7 @@ void testIntArray() { void testLongArray() { printf("\ntestLongArray\n"); PVScalarArray *pvScalarArray = - getStandardField()->scalarArrayValue(pvLong); + getStandardPVField()->scalarArrayValue(pvLong); PVLongArray *pvValue = (PVLongArray *)pvScalarArray; int length = 5; epicsInt64 *value = new epicsInt64[length]; @@ -165,7 +166,7 @@ void testLongArray() { void testFloatArray() { printf("\ntestFloatArray\n"); PVScalarArray *pvScalarArray = - getStandardField()->scalarArrayValue(pvFloat); + getStandardPVField()->scalarArrayValue(pvFloat); PVFloatArray *pvValue = (PVFloatArray *)pvScalarArray; int length = 5; float *value = new float[length]; @@ -194,7 +195,7 @@ void testFloatArray() { void testDoubleArray() { printf("\ntestDoubleArray\n"); PVScalarArray *pvScalarArray = - getStandardField()->scalarArrayValue(pvDouble); + getStandardPVField()->scalarArrayValue(pvDouble); PVDoubleArray *pvValue = (PVDoubleArray *)pvScalarArray; int length = 5; double *value = new double[length]; @@ -223,7 +224,7 @@ void testDoubleArray() { void testStringArray() { printf("\ntestStringArray\n"); PVScalarArray *pvScalarArray = - getStandardField()->scalarArrayValue(pvString); + getStandardPVField()->scalarArrayValue(pvString); PVStringArray *pvValue = (PVStringArray *)pvScalarArray; int length = 5; String *value = new String[length];