added StandardPVField

StandardField, which creates standard introspection interfaces, is complele
2010-10-27 08:18:31 -04:00
parent c8e3f82ac3
commit 4e5e4ea782
15 changed files with 890 additions and 62 deletions
@@ -1,70 +1,457 @@
 /* StandardField.cpp */
 #include <string>
+#include <cstdio>
 #include <stdexcept>
 #include <lock.h>
 #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;
 }

 }}