added StandardPVField

StandardField, which creates standard introspection interfaces, is complele

QtC-pvData.creator.user

@@ -0,0 +1,66 @@
+<!DOCTYPE QtCreatorProject>
+<qtcreator>
+ <data>
+  <variable>GenericProjectManager.GenericProject.Toolchain</variable>
+  <value type="int">0</value>
+ </data>
+ <data>
+  <variable>ProjectExplorer.Project.ActiveTarget</variable>
+  <value type="int">0</value>
+ </data>
+ <data>
+  <variable>ProjectExplorer.Project.EditorSettings</variable>
+  <valuemap type="QVariantMap">
+   <value key="EditorConfiguration.Codec" type="QByteArray">System</value>
+  </valuemap>
+ </data>
+ <data>
+  <variable>ProjectExplorer.Project.Target.0</variable>
+  <valuemap type="QVariantMap">
+   <value key="ProjectExplorer.ProjectConfiguration.DisplayName" type="QString">Desktop</value>
+   <value key="ProjectExplorer.ProjectConfiguration.Id" type="QString">GenericProjectManager.GenericTarget</value>
+   <value key="ProjectExplorer.Target.ActiveBuildConfiguration" type="int">0</value>
+   <value key="ProjectExplorer.Target.ActiveRunConfiguration" type="int">0</value>
+   <valuemap key="ProjectExplorer.Target.BuildConfiguration.0" type="QVariantMap">
+    <value key="GenericProjectManager.GenericBuildConfiguration.BuildDirectory" type="QString">/home/mrk/hgwork/pvDataCPP</value>
+    <valuemap key="ProjectExplorer.BuildConfiguration.BuildStep.0" type="QVariantMap">
+     <valuelist key="GenericProjectManager.GenericMakeStep.BuildTargets" type="QVariantList">
+      <value type="QString">all</value>
+     </valuelist>
+     <valuelist key="GenericProjectManager.GenericMakeStep.MakeArguments" type="QVariantList"/>
+     <value key="GenericProjectManager.GenericMakeStep.MakeCommand" type="QString"></value>
+     <value key="ProjectExplorer.ProjectConfiguration.DisplayName" type="QString">Make</value>
+     <value key="ProjectExplorer.ProjectConfiguration.Id" type="QString">GenericProjectManager.GenericMakeStep</value>
+    </valuemap>
+    <value key="ProjectExplorer.BuildConfiguration.BuildStepsCount" type="int">1</value>
+    <value key="ProjectExplorer.BuildConfiguration.CleanStepsCount" type="int">0</value>
+    <value key="ProjectExplorer.BuildConfiguration.ClearSystemEnvironment" type="bool">false</value>
+    <valuelist key="ProjectExplorer.BuildConfiguration.UserEnvironmentChanges" type="QVariantList"/>
+    <value key="ProjectExplorer.ProjectConfiguration.DisplayName" type="QString">all</value>
+    <value key="ProjectExplorer.ProjectConfiguration.Id" type="QString">GenericProjectManager.GenericBuildConfiguration</value>
+   </valuemap>
+   <value key="ProjectExplorer.Target.BuildConfigurationCount" type="int">1</value>
+   <valuemap key="ProjectExplorer.Target.RunConfiguration.0" type="QVariantMap">
+    <valuelist key="ProjectExplorer.CustomExecutableRunConfiguration.Arguments" type="QVariantList"/>
+    <value key="ProjectExplorer.CustomExecutableRunConfiguration.BaseEnvironmentBase" type="int">2</value>
+    <value key="ProjectExplorer.CustomExecutableRunConfiguration.Executable" type="QString">/home/mrk/hgwork/pvDataCPP/bin/linux-x86/testIntrospect</value>
+    <value key="ProjectExplorer.CustomExecutableRunConfiguration.UseTerminal" type="bool">false</value>
+    <valuelist key="ProjectExplorer.CustomExecutableRunConfiguration.UserEnvironmentChanges" type="QVariantList"/>
+    <value key="ProjectExplorer.CustomExecutableRunConfiguration.UserName" type="QString">testIntrospect</value>
+    <value key="ProjectExplorer.CustomExecutableRunConfiguration.UserSetName" type="bool">true</value>
+    <value key="ProjectExplorer.CustomExecutableRunConfiguration.WorkingDirectory" type="QString">$BUILDDIR</value>
+    <value key="ProjectExplorer.ProjectConfiguration.DisplayName" type="QString">testIntrospect</value>
+    <value key="ProjectExplorer.ProjectConfiguration.Id" type="QString">ProjectExplorer.CustomExecutableRunConfiguration</value>
+   </valuemap>
+   <value key="ProjectExplorer.Target.RunConfigurationCount" type="int">1</value>
+  </valuemap>
+ </data>
+ <data>
+  <variable>ProjectExplorer.Project.TargetCount</variable>
+  <value type="int">1</value>
+ </data>
+ <data>
+  <variable>ProjectExplorer.Project.Updater.FileVersion</variable>
+  <value type="int">4</value>
+ </data>
+</qtcreator>

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

pvDataApp/Makefile

@@ -4,5 +4,6 @@ DIRS += misc
 DIRS += pv
 DIRS += factory
 DIRS += test
+DIRS += pvTest
 include $(TOP)/configure/RULES_DIRS
 

pvDataApp/factory/Makefile

@@ -32,6 +32,7 @@ LIBSRCS += FieldCreateFactory.cpp
 LIBSRCS += PVDataCreateFactory.cpp
 LIBSRCS += Convert.cpp
 LIBSRCS += StandardField.cpp
+LIBSRCS += StandardPVField.cpp
 
 LIBRARY=pvFactory
 

pvDataApp/factory/StandardField.cpp

@@ -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;
 }
 
 }}

pvDataApp/factory/StandardPVField.cpp

@@ -0,0 +1,213 @@
+/* StandardPVField.cpp */
+#include <string>
+#include <stdexcept>
+#include <lock.h>
+#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;
+}
+
+}}

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
 #----------------------------------------

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();

pvDataApp/pv/standardPVField.h

@@ -0,0 +1,53 @@
+/* standardPVField.h */
+#include <string>
+#include <stdexcept>
+#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 */

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
+

pvDataApp/pvTest/testIntrospect.cpp

@@ -0,0 +1,44 @@
+/* testSimpleStructure.cpp */
+/* Author:  Marty Kraimer Date: 2010.09 */
+
+#include <cstddef>
+#include <cstdlib>
+#include <cstddef>
+#include <string>
+#include <cstdio>
+
+#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);
+}
+

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

pvDataApp/test/testIntrospectScalar.cpp

@@ -0,0 +1,24 @@
+/* testIntrospectScalar.cpp */
+/* Author:  Marty Kraimer Date: 2010.10 */
+
+#include <stddef.h>
+#include <stdlib.h>
+#include <stddef.h>
+#include <string.h>
+#include <stdio.h>
+
+#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);
+}

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);

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];