diff --git a/pvDataApp/factory/Convert.cpp b/pvDataApp/factory/Convert.cpp
index 23e1af3..036cb38 100644
--- a/pvDataApp/factory/Convert.cpp
+++ b/pvDataApp/factory/Convert.cpp
@@ -376,13 +376,13 @@ static size_t convertToStringArray(PVScalarArray *pv, size_t offset,
     size_t len,StringArray & to, size_t toOffset);
 
 static void convertToString(StringBuilder buffer,
-    PVField *pv,int indentLevel);
+    PVField const  *pv,int indentLevel);
 static void convertStructure(StringBuilder buffer,
-    PVStructure *data,int indentLevel);
+    PVStructure const *data,int indentLevel);
 static void convertArray(StringBuilder buffer,
-    PVScalarArray * pv,int indentLevel);
+    PVScalarArray  const* pv,int indentLevel);
 static void convertStructureArray(StringBuilder buffer,
-    PVStructureArray * pvdata,int indentLevel);
+    PVStructureArray const * pvdata,int indentLevel);
 static size_t copyArrayDataReference(PVScalarArray *from,PVArray *to);
 static size_t copyNumericArray(PVScalarArray *from,
     size_t offset, PVScalarArray *to, size_t toOffset, size_t len);
@@ -448,12 +448,12 @@ void Convert::getString(StringBuilder buf,PVFieldPtr const & pvField)
     convertToString(buf,pvField.get(),0);
 }
 
-void Convert::getString(StringBuilder buf,PVField *pvField,int indentLevel)
+void Convert::getString(StringBuilder buf,PVField const *pvField,int indentLevel)
 {
     convertToString(buf,pvField,indentLevel);
 }
 
-void Convert::getString(StringBuilder buf,PVField *pvField)
+void Convert::getString(StringBuilder buf,PVField const *pvField)
 {
     convertToString(buf,pvField,0);
 }
@@ -1233,121 +1233,121 @@ size_t Convert::toDoubleArray(PVScalarArrayPtr const &pv, size_t offset, size_t
     return convertToDoubleArray(pv.get(), offset, length, to, toOffset);
 }
 
-size_t Convert::fromByteArray(PVScalarArrayPtr const &pv, size_t offset, size_t length,
+size_t Convert::fromByteArray(PVScalarArrayPtr &pv, size_t offset, size_t length,
     const int8 from[], size_t fromOffset)
 {
     return convertFromByteArray(pv.get(), offset, length, from, fromOffset);
 }
 
-size_t Convert::fromByteArray(PVScalarArrayPtr const &pv, size_t offset, size_t length,
+size_t Convert::fromByteArray(PVScalarArrayPtr &pv, size_t offset, size_t length,
     const ByteArray & from, size_t fromOffset)
 {
     return convertFromByteArray(pv.get(), offset, length, get(from), fromOffset);
 }
 
-size_t Convert::fromShortArray(PVScalarArrayPtr const &pv, size_t offset, size_t length,
+size_t Convert::fromShortArray(PVScalarArrayPtr &pv, size_t offset, size_t length,
     const int16 from[], size_t fromOffset)
 {
     return convertFromShortArray(pv.get(), offset, length, from, fromOffset);
 }
 
-size_t Convert::fromShortArray(PVScalarArrayPtr const &pv, size_t offset, size_t length,
+size_t Convert::fromShortArray(PVScalarArrayPtr &pv, size_t offset, size_t length,
     const ShortArray & from, size_t fromOffset)
 {
     return convertFromShortArray(pv.get(), offset, length, get(from), fromOffset);
 }
 
-size_t Convert::fromIntArray(PVScalarArrayPtr const &pv, size_t offset, size_t length,
+size_t Convert::fromIntArray(PVScalarArrayPtr &pv, size_t offset, size_t length,
     const int32 from[], size_t fromOffset)
 {
     return convertFromIntArray(pv.get(), offset, length, from, fromOffset);
 }
 
-size_t Convert::fromIntArray(PVScalarArrayPtr const &pv, size_t offset, size_t length,
+size_t Convert::fromIntArray(PVScalarArrayPtr &pv, size_t offset, size_t length,
     const IntArray & from, size_t fromOffset)
 {
     return convertFromIntArray(pv.get(), offset, length, get(from), fromOffset);
 }
 
-size_t Convert::fromLongArray(PVScalarArrayPtr const &pv, size_t offset, size_t length,
+size_t Convert::fromLongArray(PVScalarArrayPtr &pv, size_t offset, size_t length,
     const int64 from[], size_t fromOffset)
 {
     return convertFromLongArray(pv.get(), offset, length, from, fromOffset);
 }
 
-size_t Convert::fromLongArray(PVScalarArrayPtr const &pv, size_t offset, size_t length,
+size_t Convert::fromLongArray(PVScalarArrayPtr &pv, size_t offset, size_t length,
     const LongArray & from, size_t fromOffset)
 {
     return convertFromLongArray(pv.get(), offset, length, get(from), fromOffset);
 }
 
-size_t Convert::fromUByteArray(PVScalarArrayPtr const &pv, size_t offset, size_t length,
+size_t Convert::fromUByteArray(PVScalarArrayPtr &pv, size_t offset, size_t length,
     const uint8 from[], size_t fromOffset)
 {
     return convertFromUByteArray(pv.get(), offset, length, from, fromOffset);
 }
 
-size_t Convert::fromUByteArray(PVScalarArrayPtr const &pv, size_t offset, size_t length,
+size_t Convert::fromUByteArray(PVScalarArrayPtr &pv, size_t offset, size_t length,
     const UByteArray & from, size_t fromOffset)
 {
     return convertFromUByteArray(pv.get(), offset, length, get(from), fromOffset);
 }
 
-size_t Convert::fromUShortArray(PVScalarArrayPtr const &pv, size_t offset, size_t length,
+size_t Convert::fromUShortArray(PVScalarArrayPtr &pv, size_t offset, size_t length,
     const uint16 from[], size_t fromOffset)
 {
     return convertFromUShortArray(pv.get(), offset, length, from, fromOffset);
 }
 
-size_t Convert::fromUShortArray(PVScalarArrayPtr const &pv, size_t offset, size_t length,
+size_t Convert::fromUShortArray(PVScalarArrayPtr &pv, size_t offset, size_t length,
     const UShortArray &from, size_t fromOffset)
 {
     return convertFromUShortArray(pv.get(), offset, length, get(from), fromOffset);
 }
 
-size_t Convert::fromUIntArray(PVScalarArrayPtr const &pv, size_t offset, size_t length,
+size_t Convert::fromUIntArray(PVScalarArrayPtr &pv, size_t offset, size_t length,
     const uint32 from[], size_t fromOffset)
 {
     return convertFromUIntArray(pv.get(), offset, length, from, fromOffset);
 }
 
-size_t Convert::fromUIntArray(PVScalarArrayPtr const &pv, size_t offset, size_t length,
+size_t Convert::fromUIntArray(PVScalarArrayPtr &pv, size_t offset, size_t length,
     const UIntArray & from, size_t fromOffset)
 {
     return convertFromUIntArray(pv.get(), offset, length, get(from), fromOffset);
 }
 
-size_t Convert::fromULongArray(PVScalarArrayPtr const &pv, size_t offset, size_t length,
+size_t Convert::fromULongArray(PVScalarArrayPtr &pv, size_t offset, size_t length,
     const uint64 from[], size_t fromOffset)
 {
     return convertFromULongArray(pv.get(), offset, length, from, fromOffset);
 }
 
-size_t Convert::fromULongArray(PVScalarArrayPtr const &pv, size_t offset, size_t length,
+size_t Convert::fromULongArray(PVScalarArrayPtr &pv, size_t offset, size_t length,
     const ULongArray &from, size_t fromOffset)
 {
     return convertFromULongArray(pv.get(), offset, length, get(from), fromOffset);
 }
 
-size_t Convert::fromFloatArray(PVScalarArrayPtr const &pv, size_t offset, size_t length,
+size_t Convert::fromFloatArray(PVScalarArrayPtr &pv, size_t offset, size_t length,
     const float from[], size_t fromOffset)
 {
     return convertFromFloatArray(pv.get(), offset, length, from, fromOffset);
 }
 
-size_t Convert::fromFloatArray(PVScalarArrayPtr const &pv, size_t offset, size_t length,
+size_t Convert::fromFloatArray(PVScalarArrayPtr &pv, size_t offset, size_t length,
     const FloatArray & from, size_t fromOffset)
 {
     return convertFromFloatArray(pv.get(), offset, length, get(from), fromOffset);
 }
 
-size_t Convert::fromDoubleArray(PVScalarArrayPtr const &pv, size_t offset, size_t length,
+size_t Convert::fromDoubleArray(PVScalarArrayPtr &pv, size_t offset, size_t length,
     const double from[], size_t fromOffset)
 {
     return convertFromDoubleArray(pv.get(), offset, length, from, fromOffset);
 }
 
-size_t Convert::fromDoubleArray(PVScalarArrayPtr const &pv, size_t offset, size_t length,
+size_t Convert::fromDoubleArray(PVScalarArrayPtr &pv, size_t offset, size_t length,
     const DoubleArray & from, size_t fromOffset)
 {
     return convertFromDoubleArray(pv.get(), offset, length, get(from), fromOffset);
@@ -2604,24 +2604,24 @@ size_t convertToStringArray(PVScalarArray *pv,
 }
 
 
-void convertToString(StringBuilder buffer,PVField * pv,int indentLevel)
+void convertToString(StringBuilder buffer,PVField const * pv,int indentLevel)
 {
     Type type = pv->getField()->getType();
     if(type==scalarArray) {
-        convertArray(buffer,static_cast<PVScalarArray *>(pv),indentLevel);
+        convertArray(buffer,static_cast<PVScalarArray const *>(pv),indentLevel);
         return;
     }
     if(type==structure) {
-        convertStructure(buffer,static_cast<PVStructure*>(pv),indentLevel);
+        convertStructure(buffer,static_cast<PVStructure const *>(pv),indentLevel);
         return;
     }
     if(type==structureArray) {
     	convertStructureArray(
-            buffer,static_cast<PVStructureArray*>(pv),indentLevel);
+            buffer,static_cast<PVStructureArray const *>(pv),indentLevel);
         return;
     }
-    PVScalar *pvScalar = static_cast<PVScalar*>(pv);
-    ScalarConstPtr pscalar = pvScalar->getScalar();
+    PVScalar const *pvScalar = static_cast<PVScalar const *>(pv);
+    const ScalarConstPtr & pscalar = pvScalar->getScalar();
     ScalarType scalarType = pscalar->getScalarType();
     ScalarTypeFunc::toString(buffer,scalarType);
     *buffer += " ";
@@ -2629,7 +2629,7 @@ void convertToString(StringBuilder buffer,PVField * pv,int indentLevel)
     *buffer += " ";
     switch(scalarType) {
     case pvBoolean: {
-            PVBoolean *data = static_cast<PVBoolean*>(pv);
+            PVBoolean const *data = static_cast<PVBoolean const *>(pv);
             bool value = data->get();
             if(value) {
                 *buffer += "true";
@@ -2639,77 +2639,77 @@ void convertToString(StringBuilder buffer,PVField * pv,int indentLevel)
         }
         return;
     case pvByte: {
-            PVByte *data = static_cast<PVByte*>(pv);
+            PVByte const *data = static_cast<PVByte const *>(pv);
             char xxx[30];
             sprintf(xxx,"%d",(int)data->get());
             *buffer += xxx;
         }
         return;
     case pvShort: {
-            PVShort *data = static_cast<PVShort*>(pv);
+            PVShort const  *data = static_cast<PVShort const *>(pv);
             char xxx[30];
             sprintf(xxx,"%d",(int)data->get());
             *buffer += xxx;
         }
         return;
     case pvInt: {
-            PVInt *data = static_cast<PVInt*>(pv);
+            PVInt const  *data = static_cast<PVInt const *>(pv);
             char xxx[30];
             sprintf(xxx,"%d",(int)data->get());
             *buffer += xxx;
         }
         return;
     case pvLong: {
-            PVLong *data = static_cast<PVLong*>(pv);
+            PVLong const  *data = static_cast<PVLong const *>(pv);
             char xxx[30];
             sprintf(xxx,"%lld",(long long)data->get());
             *buffer += xxx;
         }
         return;
     case pvUByte: {
-            PVUByte *data = static_cast<PVUByte*>(pv);
+            PVUByte const  *data = static_cast<PVUByte const *>(pv);
             char xxx[30];
             sprintf(xxx,"%u",(unsigned int)data->get());
             *buffer += xxx;
         }
         return;
     case pvUShort: {
-            PVUShort *data = static_cast<PVUShort*>(pv);
+            PVUShort const  *data = static_cast<PVUShort const *>(pv);
             char xxx[30];
             sprintf(xxx,"%u",(unsigned int)data->get());
             *buffer += xxx;
         }
         return;
     case pvUInt: {
-            PVUInt *data = static_cast<PVUInt*>(pv);
+            PVUInt const  *data = static_cast<PVUInt const *>(pv);
             char xxx[30];
             sprintf(xxx,"%u",(unsigned int)data->get());
             *buffer += xxx;
         }
         return;
     case pvULong: {
-            PVULong *data = static_cast<PVULong*>(pv);
+            PVULong const  *data = static_cast<PVULong const *>(pv);
             char xxx[30];
             sprintf(xxx,"%llu",(unsigned long long)data->get());
             *buffer += xxx;
         }
         return;
     case pvFloat: {
-            PVFloat *data = static_cast<PVFloat*>(pv);
+            PVFloat const  *data = static_cast<PVFloat const *>(pv);
             char xxx[30];
             sprintf(xxx,"%g",data->get());
             *buffer += xxx;
         }
         return;
     case pvDouble: {
-            PVDouble *data = static_cast<PVDouble*>(pv);
+            PVDouble const  *data = static_cast<PVDouble const *>(pv);
             char xxx[30];
             sprintf(xxx,"%lg",data->get());
             *buffer += xxx;
         }
         return;
     case pvString: {
-            PVString *data = static_cast<PVString*>(pv);
+            PVString const  *data = static_cast<PVString const *>(pv);
             *buffer += data->get();
         }
         return;
@@ -2718,7 +2718,7 @@ void convertToString(StringBuilder buffer,PVField * pv,int indentLevel)
     }
 }
 
-void convertStructure(StringBuilder buffer,PVStructure *data,int indentLevel)
+void convertStructure(StringBuilder buffer,PVStructure const *data,int indentLevel)
 {
     String extendsName = data->getExtendsStructureName();
     if(extendsName.length()<=0) {
@@ -2739,8 +2739,9 @@ void convertStructure(StringBuilder buffer,PVStructure *data,int indentLevel)
     }
 }
 
-void convertArray(StringBuilder buffer,PVScalarArray * pv,int indentLevel)
+void convertArray(StringBuilder buffer,PVScalarArray const * xxx,int indentLevel)
 {
+    PVScalarArray *pv = const_cast<PVScalarArray *>(xxx);
     ScalarArrayConstPtr array = pv->getScalarArray();
     ScalarType type = array->getElementType();
     ScalarTypeFunc::toString(buffer,type);
@@ -2749,7 +2750,7 @@ void convertArray(StringBuilder buffer,PVScalarArray * pv,int indentLevel)
     *buffer += " ";
     switch(type) {
     case pvBoolean: {
-            PVBooleanArray *pvdata = static_cast<PVBooleanArray*>(pv);
+            PVBooleanArray *pvdata = static_cast<PVBooleanArray *>(pv);
             BooleanArrayData data;
             *buffer += "[";
             for(size_t i=0; i < pvdata->getLength(); i++) {
@@ -2989,8 +2990,9 @@ void convertArray(StringBuilder buffer,PVScalarArray * pv,int indentLevel)
 }
 
 void convertStructureArray(StringBuilder buffer,
-    PVStructureArray * pvdata,int indentLevel)
+    PVStructureArray const * xxx,int indentLevel)
 {
+     PVStructureArray *pvdata = const_cast<PVStructureArray *>(xxx);
     *buffer += "structure[] ";
     *buffer += pvdata->getFieldName();
     *buffer += " ";
diff --git a/pvDataApp/factory/PVArray.cpp b/pvDataApp/factory/PVArray.cpp
index 8f981ac..78a2b95 100644
--- a/pvDataApp/factory/PVArray.cpp
+++ b/pvDataApp/factory/PVArray.cpp
@@ -57,7 +57,7 @@ namespace epics { namespace pvData {
      }
 
 
-     bool PVArray::isCapacityMutable() 
+     bool PVArray::isCapacityMutable() const
      {
           if(PVField::isImmutable()) {
               return false;
diff --git a/pvDataApp/factory/PVDataCreateFactory.cpp b/pvDataApp/factory/PVDataCreateFactory.cpp
index 9f7cfc2..9ca8b98 100644
--- a/pvDataApp/factory/PVDataCreateFactory.cpp
+++ b/pvDataApp/factory/PVDataCreateFactory.cpp
@@ -37,7 +37,7 @@ public:
 
     BasePVScalar(ScalarConstPtr const & scalar);
     virtual ~BasePVScalar();
-    virtual T get();
+    virtual T get() const ;
     virtual void put(T val);
     virtual void serialize(ByteBuffer *pbuffer,
         SerializableControl *pflusher) const;
@@ -57,7 +57,7 @@ template<typename T>
 BasePVScalar<T>::~BasePVScalar() {}
 
 template<typename T>
-T BasePVScalar<T>::get() { return value;}
+T BasePVScalar<T>::get() const  { return value;}
 
 template<typename T>
 void BasePVScalar<T>::put(T val){value = val;}
@@ -98,7 +98,7 @@ public:
 
     BasePVString(ScalarConstPtr const & scalar);
     virtual ~BasePVString();
-    virtual String get();
+    virtual String get() const ;
     virtual void put(String val);
     virtual void serialize(ByteBuffer *pbuffer,
         SerializableControl *pflusher) const;
@@ -116,7 +116,7 @@ BasePVString::BasePVString(ScalarConstPtr const & scalar)
 
 BasePVString::~BasePVString() {}
 
-String BasePVString::get() { return value;}
+String BasePVString::get() const  { return value;}
 
 void BasePVString::put(String val){value = val;}
 
@@ -620,7 +620,12 @@ PVStructurePtr PVDataCreate::createPVStructure(
      FieldConstPtrArray fields(num);
      for (size_t i=0;i<num;i++) fields[i] = pvFields[i]->getField();
      StructureConstPtr structure = fieldCreate->createStructure(fieldNames,fields);
-     return PVStructurePtr(new PVStructure(structure,pvFields));
+     PVStructurePtr pvStructure(new PVStructure(structure,pvFields));
+     const PVFieldPtrArray & xxx = pvStructure->getPVFields();
+     for(size_t i=0; i<pvFields.size();i++) {
+         convert->copy(pvFields[i],xxx[i]);
+     }
+     return pvStructure;
 }
 
 PVStructurePtr PVDataCreate::createPVStructure(PVStructurePtr const & structToClone)
diff --git a/pvDataApp/factory/PVField.cpp b/pvDataApp/factory/PVField.cpp
index 26d7659..0f6b3b0 100644
--- a/pvDataApp/factory/PVField.cpp
+++ b/pvDataApp/factory/PVField.cpp
@@ -58,7 +58,7 @@ void PVField::message(String message,MessageType messageType)
     PVField::message(fieldName,message,messageType);
 }
 
-String PVField::getFieldName()
+String PVField::getFieldName() const
 {
     return fieldName;
 }
@@ -77,19 +77,19 @@ void PVField::setRequester(Requester *requester)
     requester = requester;
 }
 
-size_t PVField::getFieldOffset() 
+size_t PVField::getFieldOffset() const
 {
     if(nextFieldOffset==0) computeOffset(this);
     return fieldOffset;
 }
 
-size_t PVField::getNextFieldOffset() 
+size_t PVField::getNextFieldOffset() const
 {
     if(nextFieldOffset==0) computeOffset(this);
     return nextFieldOffset;
 }
 
-size_t PVField::getNumberFields() 
+size_t PVField::getNumberFields() const
 {
     if(nextFieldOffset==0) computeOffset(this);
     return (nextFieldOffset - fieldOffset);
@@ -102,15 +102,15 @@ PVAuxInfoPtr & PVField::getPVAuxInfo(){
     return pvAuxInfo;
 }
 
-bool PVField::isImmutable()  {return immutable;}
+bool PVField::isImmutable() const {return immutable;}
 
 void PVField::setImmutable() {immutable = true;}
 
-FieldConstPtr & PVField::getField()  {return field;}
+const FieldConstPtr & PVField::getField() const {return field;}
 
-PVStructure *PVField::getParent()  {return parent;}
+PVStructure *PVField::getParent() const {return parent;}
 
-void PVField::replacePVField(PVFieldPtr & newPVField)
+void PVField::replacePVField(const PVFieldPtr & newPVField)
 {
     if(parent==NULL) {
         throw std::logic_error("no parent");
@@ -189,15 +189,16 @@ void PVField::toString(StringBuilder buf,int indentLevel)
    if(pvAuxInfo.get()!=NULL) pvAuxInfo->toString(buf,indentLevel);
 }
 
-void PVField::computeOffset(PVField   *  pvField) {
-    PVStructure * pvTop = pvField->getParent();
+void PVField::computeOffset(const PVField   *  pvField) {
+    const PVStructure * pvTop = pvField->getParent();
     if(pvTop==NULL) {
         if(pvField->getField()->getType()!=structure) {
-           pvField->fieldOffset = 0;
-           pvField->nextFieldOffset = 1;
+           PVField *xxx = const_cast<PVField *>(pvField);
+           xxx->fieldOffset = 0;
+           xxx->nextFieldOffset = 1;
            return;
         }
-        pvTop = static_cast<PVStructure *>(pvField);
+        pvTop = static_cast<const PVStructure *>(pvField);
     } else {
         while(pvTop->getParent()!=NULL) pvTop = pvTop->getParent();
     }
@@ -224,15 +225,16 @@ void PVField::computeOffset(PVField   *  pvField) {
         }
     }
     PVField *top = (PVField *)pvTop;
-    top->fieldOffset = 0;
-    top->nextFieldOffset = nextOffset;
+    PVField *xxx = const_cast<PVField *>(top);
+    xxx->fieldOffset = 0;
+    xxx->nextFieldOffset = nextOffset;
 }
 
-void PVField::computeOffset(PVField   *  pvField,size_t offset) {
+void PVField::computeOffset(const PVField   *  pvField,size_t offset) {
     int beginOffset = offset;
     int nextOffset = offset + 1;
-    PVStructure *pvStructure = static_cast<PVStructure *>(pvField);
-    PVFieldPtrArray  pvFields = pvStructure->getPVFields();
+    const PVStructure *pvStructure = static_cast<const PVStructure *>(pvField);
+    const PVFieldPtrArray  pvFields = pvStructure->getPVFields();
     for(size_t i=0; i < pvStructure->getStructure()->getNumberFields(); i++) {
         offset = nextOffset;
         PVField *pvSubField = pvFields[i].get();
@@ -252,8 +254,9 @@ void PVField::computeOffset(PVField   *  pvField,size_t offset) {
             }
         }
     }
-    pvField->fieldOffset = beginOffset;
-    pvField->nextFieldOffset = nextOffset;
+    PVField *xxx = const_cast<PVField *>(pvField);
+    xxx->fieldOffset = beginOffset;
+    xxx->nextFieldOffset = nextOffset;
 }
 
 }}
diff --git a/pvDataApp/factory/PVScalar.cpp b/pvDataApp/factory/PVScalar.cpp
index ca9e52b..5bf422a 100644
--- a/pvDataApp/factory/PVScalar.cpp
+++ b/pvDataApp/factory/PVScalar.cpp
@@ -20,7 +20,7 @@ namespace epics { namespace pvData {
     PVScalar::PVScalar(ScalarConstPtr const & scalar)
     : PVField(scalar) {}
 
-    ScalarConstPtr PVScalar::getScalar() 
+    const ScalarConstPtr PVScalar::getScalar() const
     {
        return static_pointer_cast<const Scalar>(PVField::getField());
     }
diff --git a/pvDataApp/factory/PVScalarArray.cpp b/pvDataApp/factory/PVScalarArray.cpp
index 69b1c91..4743a59 100644
--- a/pvDataApp/factory/PVScalarArray.cpp
+++ b/pvDataApp/factory/PVScalarArray.cpp
@@ -20,7 +20,7 @@ namespace epics { namespace pvData {
     PVScalarArray::PVScalarArray(ScalarArrayConstPtr const & scalarArray)
     : PVArray(scalarArray) {}
 
-    ScalarArrayConstPtr PVScalarArray::getScalarArray() 
+    const ScalarArrayConstPtr PVScalarArray::getScalarArray() const
     {
        return static_pointer_cast<const ScalarArray>(PVField::getField());
     }
diff --git a/pvDataApp/factory/PVStructure.cpp b/pvDataApp/factory/PVStructure.cpp
index 04ae4f8..0186576 100644
--- a/pvDataApp/factory/PVStructure.cpp
+++ b/pvDataApp/factory/PVStructure.cpp
@@ -37,7 +37,7 @@ static PVStructurePtr nullPVStructure;
 static PVStructureArrayPtr nullPVStructureArray;
 static PVScalarArrayPtr nullPVScalarArray;
 
-static PVFieldPtr findSubField(String fieldName,PVStructure *pvStructure);
+static PVFieldPtr findSubField(String fieldName,const PVStructure *pvStructure);
 
 PVStructure::PVStructure(StructureConstPtr const & structurePtr)
 : PVField(structurePtr),
@@ -47,13 +47,14 @@ PVStructure::PVStructure(StructureConstPtr const & structurePtr)
     size_t numberFields = structurePtr->getNumberFields();
     FieldConstPtrArray fields = structurePtr->getFields();
     StringArray fieldNames = structurePtr->getFieldNames();
-    pvFields.reserve(numberFields);
+    PVFieldPtrArray * xxx = const_cast<PVFieldPtrArray *>(&pvFields);
+    xxx->reserve(numberFields);
     PVDataCreatePtr pvDataCreate = getPVDataCreate();
     for(size_t i=0; i<numberFields; i++) {
-        pvFields.push_back(pvDataCreate->createPVField(fields[i]));
+        xxx->push_back(pvDataCreate->createPVField(fields[i]));
     }
     for(size_t i=0; i<numberFields; i++) {
-        pvFields[i]->setParentAndName(this,fieldNames[i]);
+        (*xxx)[i]->setParentAndName(this,fieldNames[i]);
     }
 }
 
@@ -66,9 +67,14 @@ PVStructure::PVStructure(StructureConstPtr const & structurePtr,
 {
     size_t numberFields = structurePtr->getNumberFields();
     StringArray fieldNames = structurePtr->getFieldNames();
-    pvFields = pvs;
+    PVFieldPtrArray * xxx = const_cast<PVFieldPtrArray *>(&pvFields);
+    xxx->reserve(numberFields);
+    PVDataCreatePtr pvDataCreate = getPVDataCreate();
     for(size_t i=0; i<numberFields; i++) {
-        pvFields[i]->setParentAndName(this,fieldNames[i]);
+        xxx->push_back(pvDataCreate->createPVField(pvs[i]->getField()));
+    }
+    for(size_t i=0; i<numberFields; i++) {
+        (*xxx)[i]->setParentAndName(this,fieldNames[i]);
     }
 }
 
@@ -76,23 +82,23 @@ PVStructure::~PVStructure()
 {
 }
 
-StructureConstPtr  &PVStructure::getStructure()
+StructureConstPtr PVStructure::getStructure() const
 {
     return structurePtr;
 }
 
-PVFieldPtrArray & PVStructure::getPVFields()
+const PVFieldPtrArray & PVStructure::getPVFields() const
 {
     return pvFields;
 }
 
-PVFieldPtr  PVStructure::getSubField(String fieldName)
+PVFieldPtr  PVStructure::getSubField(String fieldName) const
 {
     return findSubField(fieldName,this);
 }
 
 
-PVFieldPtr  PVStructure::getSubField(size_t fieldOffset)
+PVFieldPtr  PVStructure::getSubField(size_t fieldOffset) const
 {
     if(fieldOffset<=getFieldOffset()) {
         return nullPVField;
@@ -115,13 +121,8 @@ void PVStructure::appendPVField(String fieldName, PVFieldPtr const & pvField)
 {
     size_t origLength = pvFields.size();
     size_t newLength = origLength+1;
-    PVFieldPtrArray newPVFields;
-    newPVFields.reserve(newLength);
-    for(size_t i=0; i<origLength; i++) {
-        newPVFields.push_back(pvFields[i]);
-    }
-    newPVFields.push_back(pvField);
-    pvFields.swap(newPVFields);
+    PVFieldPtrArray * xxx = const_cast<PVFieldPtrArray *>(&pvFields);
+    xxx->push_back(pvField);
     FieldConstPtr field = getFieldCreate()->appendField(structurePtr,fieldName,pvField->getField());
     replaceField(field);
     structurePtr = static_pointer_cast<const Structure>(field);
@@ -137,15 +138,11 @@ void PVStructure::appendPVFields(StringArray const & fieldNames, PVFieldPtrArray
     size_t extra = fieldNames.size();
     if(extra==0) return;
     size_t newLength = origLength + extra;
-    PVFieldPtrArray newPVFields;
-    newPVFields.reserve(newLength);
-    for(size_t i=0; i<origLength; i++) {
-        newPVFields.push_back(this->pvFields[i]);
-    }
+    PVFieldPtrArray * xxx = const_cast<PVFieldPtrArray *>(&this->pvFields);
+    xxx->reserve(newLength);
     for(size_t i=0; i<extra; i++) {
-        newPVFields.push_back(pvFields[i]);
+        xxx->push_back(pvFields[i]);
     }
-    this->pvFields.swap(newPVFields);
     FieldConstPtrArray fields;
     fields.reserve(extra);
     for(size_t i=0; i<extra; i++) fields.push_back(pvFields[i]->getField());
@@ -154,7 +151,7 @@ void PVStructure::appendPVFields(StringArray const & fieldNames, PVFieldPtrArray
     structurePtr = static_pointer_cast<const Structure>(field);
     StringArray names = structurePtr->getFieldNames();
     for(size_t i=0; i<newLength; i++) {
-        pvFields[i]->setParentAndName(this,names[i]);
+        (*xxx)[i]->setParentAndName(this,names[i]);
     }
 }
 
@@ -184,7 +181,8 @@ void PVStructure::removePVField(String fieldName)
             fields.push_back(origFields[i]);
         }
     }
-    pvFields.swap(newPVFields);
+    PVFieldPtrArray * xxx = const_cast<PVFieldPtrArray *>(&pvFields);
+    xxx->swap(newPVFields);
     FieldConstPtr field = getFieldCreate()->createStructure(newFieldNames,fields);
     replaceField(field);
     structurePtr = static_pointer_cast<const Structure>(field);
@@ -525,7 +523,7 @@ PVStructureArrayPtr PVStructure::getStructureArrayField(
     return nullPVStructureArray;
 }
 
-String PVStructure::getExtendsStructureName()
+String PVStructure::getExtendsStructureName() const
 {
     return extendsStructureName;
 }
@@ -621,7 +619,7 @@ void PVStructure::deserialize(ByteBuffer *pbuffer,
     }
 }
 
-static PVFieldPtr findSubField(String fieldName,PVStructure *pvStructure) {
+static PVFieldPtr findSubField(String fieldName,PVStructure const *pvStructure) {
     if( fieldName.length()<1) return nullPVField;
     String::size_type index = fieldName.find('.');
     String name = fieldName;
diff --git a/pvDataApp/factory/PVStructureArray.cpp b/pvDataApp/factory/PVStructureArray.cpp
index e8b898e..9d5720f 100644
--- a/pvDataApp/factory/PVStructureArray.cpp
+++ b/pvDataApp/factory/PVStructureArray.cpp
@@ -98,7 +98,7 @@ void PVStructureArray::setCapacity(size_t capacity) {
 }
 
 
-StructureArrayConstPtr PVStructureArray::getStructureArray()
+StructureArrayConstPtr PVStructureArray::getStructureArray() const
 {
     return structureArray;
 }
diff --git a/pvDataApp/pv/convert.h b/pvDataApp/pv/convert.h
index 504ec43..d34f527 100644
--- a/pvDataApp/pv/convert.h
+++ b/pvDataApp/pv/convert.h
@@ -112,14 +112,14 @@ public:
      * If a PVField is a structure or array be prepared for a very long string.
      * @param indentLevel indentation level
      */
-    void getString(StringBuilder buf,PVField * pvField,int indentLevel);
+    void getString(StringBuilder buf,PVField const * pvField,int indentLevel);
     /**
      * Convert a PVField to a string.
      * param buf buffer for the result
      * @param pv The PVField to convert to a string.
      * If the PVField is a structure or array be prepared for a very long string.
      */
-    void getString(StringBuilder buf,PVField * pvField);
+    void getString(StringBuilder buf,PVField const * pvField);
      /**
       * Convert from an array of String to a PVScalar
       * @param pv The PV.
@@ -127,7 +127,10 @@ public:
       * @param fromStartIndex The first element if the array of strings.
       * @throws std::logic_error if the array of String does not have a valid values.
       */
-    std::size_t fromString(PVStructurePtr const &pv, StringArray const & from, std::size_t fromStartIndex = 0);
+    std::size_t fromString(
+        PVStructurePtr const &pv,
+        StringArray const & from,
+        std::size_t fromStartIndex = 0);
      /**
      * Convert from a String to a PVScalar
      * @param pv The PV.
@@ -157,8 +160,11 @@ public:
      * @throws std::invalid_argument if the element Type is not a scalar.
      * @throws std::logic_error if the String does not have a valid value.
      */
-    std::size_t fromStringArray(PVScalarArrayPtr const & pv, std::size_t offset, std::size_t length,
-        StringArray const & from, std::size_t fromOffset);
+    std::size_t fromStringArray(
+        PVScalarArrayPtr const & pv,
+        std::size_t offset, std::size_t length,
+        StringArray const & from,
+        std::size_t fromOffset);
     /**
      * Convert a PVScalarArray to a String array.
      * @param pv The PV.
@@ -168,8 +174,11 @@ public:
      * @param toOffset Starting element in the string array.
      * @return Number of elements converted.
      */
-    std::size_t toStringArray(PVScalarArrayPtr const & pv, std::size_t offset, std::size_t length,
-        StringArray & to, std::size_t toOffset);
+    std::size_t toStringArray(PVScalarArrayPtr const & pv,
+        std::size_t offset,
+        std::size_t length,
+        StringArray & to,
+        std::size_t toOffset);
     /**
      * Are from and to valid arguments to copy.
      * This first checks of both arguments have the same Type.
@@ -203,7 +212,8 @@ public:
      * @return (false,true) If the arguments (are not, are) compatible.
      */
     bool isCopyScalarCompatible(
-         ScalarConstPtr const & from, ScalarConstPtr const & to);
+        ScalarConstPtr const & from,
+        ScalarConstPtr const & to);
     /**
      * Copy from a scalar pv to another scalar pv.
      * @param from the source.
@@ -218,7 +228,8 @@ public:
      * @param to The to array.
      * @return (false,true) If the arguments (are not, are) compatible.
      */
-    bool isCopyScalarArrayCompatible(ScalarArrayConstPtr const & from,
+    bool isCopyScalarArrayCompatible(
+        ScalarArrayConstPtr const & from,
         ScalarArrayConstPtr const & to);
     /**
      * Convert from a source PV array to a destination PV array.
@@ -230,8 +241,12 @@ public:
      * @return Number of elements converted.
      * @throws std::invalid_argument if the arguments are not compatible.
      */
-    std::size_t copyScalarArray(PVScalarArrayPtr const & from, std::size_t offset,
-        PVScalarArrayPtr const & to, std::size_t toOffset, std::size_t length);
+    std::size_t copyScalarArray(
+        PVScalarArrayPtr const & from,
+        std::size_t offset,
+        PVScalarArrayPtr const & to,
+        std::size_t toOffset,
+        std::size_t length);
     /**
      * Are from and to valid arguments for copyStructure.
      * They are only compatible if they have the same Structure description.
@@ -424,8 +439,11 @@ public:
      * @return number of elements converted
      * @throws std::invalid_argument if the element type is not numeric
      */
-    std::size_t toByteArray(PVScalarArrayPtr const & pv, std::size_t offset, std::size_t length,
-        int8* to, std::size_t toOffset);
+    std::size_t toByteArray(PVScalarArrayPtr const & pv,
+        std::size_t offset,
+        std::size_t length,
+        int8* to,
+        std::size_t toOffset);
     /**
      * Convert a PV array to a short array.
      * @param pv a PV
@@ -436,8 +454,11 @@ public:
      * @return number of elements converted
     * @throws std::invalid_argument if the element type is not numeric
     */
-    std::size_t toShortArray(PVScalarArrayPtr const & pv, std::size_t offset, std::size_t length,
-        int16* to, std::size_t toOffset);
+    std::size_t toShortArray(PVScalarArrayPtr const & pv,
+        std::size_t offset,
+        std::size_t length,
+        int16* to,
+        std::size_t toOffset);
     /**
      * Convert a PV array to an int array.
      * @param pv a PV
@@ -448,8 +469,11 @@ public:
      * @return number of elements converted
      * @throws std::invalid_argument if the element type is not numeric
      */
-    std::size_t toIntArray(PVScalarArrayPtr const & pv, std::size_t offset, std::size_t length,
-        int32* to, std::size_t toOffset);
+    std::size_t toIntArray(PVScalarArrayPtr const & pv,
+        std::size_t offset,
+        std::size_t length,
+        int32* to,
+        std::size_t toOffset);
     /**
      * Convert a PV array to a long array.
      * @param pv a PV
@@ -460,8 +484,11 @@ public:
      * @return number of elements converted
      * @throws std::invalid_argument if the element type is not numeric
      */
-    std::size_t toLongArray(PVScalarArrayPtr const & pv, std::size_t offset, std::size_t length,
-        int64* to, std::size_t toOffset);
+    std::size_t toLongArray(PVScalarArrayPtr const & pv,
+        std::size_t offset,
+        std::size_t length,
+        int64* to,
+        std::size_t toOffset);
     /**
      * Convert a PV array to a ubyte array.
      * @param pv a PV
@@ -472,8 +499,11 @@ public:
      * @return number of elements converted
      * @throws std::invalid_argument if the element type is not numeric
      */
-    std::size_t toUByteArray(PVScalarArrayPtr const & pv, std::size_t offset, std::size_t length,
-        uint8* to, std::size_t toOffset);
+    std::size_t toUByteArray(PVScalarArrayPtr const & pv,
+        std::size_t offset,
+        std::size_t length,
+        uint8* to,
+        std::size_t toOffset);
     /**
      * Convert a PV array to a ushort array.
      * @param pv a PV
@@ -484,8 +514,11 @@ public:
      * @return number of elements converted
     * @throws std::invalid_argument if the element type is not numeric
     */
-    std::size_t toUShortArray(PVScalarArrayPtr const & pv, std::size_t offset, std::size_t length,
-        uint16* to, std::size_t toOffset);
+    std::size_t toUShortArray(PVScalarArrayPtr const & pv,
+        std::size_t offset,
+        std::size_t length,
+        uint16* to,
+        std::size_t toOffset);
     /**
      * Convert a PV array to an uint array.
      * @param pv a PV
@@ -496,8 +529,12 @@ public:
      * @return number of elements converted
      * @throws std::invalid_argument if the element type is not numeric
      */
-    std::size_t toUIntArray(PVScalarArrayPtr const & pv, std::size_t offset, std::size_t length,
-        uint32* to, std::size_t toOffset);
+    std::size_t toUIntArray(
+        PVScalarArrayPtr const & pv,
+        std::size_t offset,
+        std::size_t length,
+        uint32* to,
+        std::size_t toOffset);
     /**
      * Convert a PV array to a ulong array.
      * @param pv a PV
@@ -508,8 +545,12 @@ public:
      * @return number of elements converted
      * @throws std::invalid_argument if the element type is not numeric
      */
-    std::size_t toULongArray(PVScalarArrayPtr const & pv, std::size_t offset, std::size_t length,
-        uint64* to, std::size_t toOffset);
+    std::size_t toULongArray(
+        PVScalarArrayPtr const & pv,
+        std::size_t offset,
+        std::size_t length,
+        uint64* to,
+        std::size_t toOffset);
      /**
       * Convert a PV array to a float array.
       * @param pv a PV
@@ -520,8 +561,12 @@ public:
       * @return number of elements converted
       * @throws std::invalid_argument if the element type is not numeric
       */
-    std::size_t toFloatArray(PVScalarArrayPtr const & pv, std::size_t offset, std::size_t length,
-        float* to, std::size_t toOffset);
+    std::size_t toFloatArray(
+        PVScalarArrayPtr const & pv,
+        std::size_t offset,
+        std::size_t length,
+        float* to,
+        std::size_t toOffset);
     /**
      * Convert a PV array to a double array.
      * @param pv a PV
@@ -532,8 +577,12 @@ public:
      * @return number of elements converted
      * @throws std::invalid_argument if the element type is not numeric
      */
-    std::size_t toDoubleArray(PVScalarArrayPtr const & pv, std::size_t offset, std::size_t length,
-        double* to, std::size_t toOffset);
+    std::size_t toDoubleArray(
+        PVScalarArrayPtr const & pv,
+        std::size_t offset,
+        std::size_t length,
+        double* to, std::size_t
+        toOffset);
     /**
      * Convert a PV array from a byte array.
      * @param pv a PV
@@ -545,10 +594,10 @@ public:
      * @throws std::invalid_argument if the element type is not numeric
      */
     std::size_t fromByteArray(
-        PVScalarArrayPtr const & pv, std::size_t offset, std::size_t length,
+        PVScalarArrayPtr & pv, std::size_t offset, std::size_t length,
         const int8* from, std::size_t fromOffset);
     std::size_t fromByteArray(
-        PVScalarArrayPtr const & pv, std::size_t offset, std::size_t length,
+        PVScalarArrayPtr & pv, std::size_t offset, std::size_t length,
         const ByteArray & from, std::size_t fromOffset);
     /**
      * Convert a PV array from a short array.
@@ -561,10 +610,10 @@ public:
      * @throws std::invalid_argument if the element type is not numeric
      */
     std::size_t fromShortArray(
-        PVScalarArrayPtr const & pv, std::size_t offset, std::size_t length,
+        PVScalarArrayPtr & pv, std::size_t offset, std::size_t length,
         const int16* from, std::size_t fromOffset);
     std::size_t fromShortArray(
-        PVScalarArrayPtr const & pv, std::size_t offset, std::size_t length,
+        PVScalarArrayPtr & pv, std::size_t offset, std::size_t length,
         const ShortArray & from, std::size_t fromOffset);
     /**
      * Convert a PV array from an int array.
@@ -577,10 +626,10 @@ public:
      * @throws std::invalid_argument if the element type is not numeric
      */
     std::size_t fromIntArray(
-       PVScalarArrayPtr const & pv, std::size_t offset, std::size_t length,
+       PVScalarArrayPtr & pv, std::size_t offset, std::size_t length,
        const int32* from, std::size_t fromOffset);
     std::size_t fromIntArray(
-       PVScalarArrayPtr const & pv, std::size_t offset, std::size_t length,
+       PVScalarArrayPtr & pv, std::size_t offset, std::size_t length,
        const IntArray & from, std::size_t fromOffset);
     /**
      * Convert a PV array from a long array.
@@ -593,10 +642,10 @@ public:
      * @throws std::invalid_argument if the element type is not numeric
      */
     std::size_t fromLongArray(
-        PVScalarArrayPtr const & pv, std::size_t offset, std::size_t length,
+        PVScalarArrayPtr & pv, std::size_t offset, std::size_t length,
         const int64* from, std::size_t fromOffset);
     std::size_t fromLongArray(
-        PVScalarArrayPtr const & pv, std::size_t offset, std::size_t length,
+        PVScalarArrayPtr & pv, std::size_t offset, std::size_t length,
         const LongArray & from, std::size_t fromOffset);
     /**
      * Convert a PV array from a ubyte array.
@@ -609,10 +658,10 @@ public:
      * @throws std::invalid_argument if the element type is not numeric
      */
     std::size_t fromUByteArray(
-        PVScalarArrayPtr const & pv, std::size_t offset, std::size_t length,
+        PVScalarArrayPtr & pv, std::size_t offset, std::size_t length,
         const uint8* from, std::size_t fromOffset);
     std::size_t fromUByteArray(
-        PVScalarArrayPtr const & pv, std::size_t offset, std::size_t length,
+        PVScalarArrayPtr & pv, std::size_t offset, std::size_t length,
         const UByteArray & from, std::size_t fromOffset);
     /**
      * Convert a PV array from a ushort array.
@@ -625,10 +674,10 @@ public:
      * @throws std::invalid_argument if the element type is not numeric
      */
     std::size_t fromUShortArray(
-        PVScalarArrayPtr const & pv, std::size_t offset, std::size_t length,
+        PVScalarArrayPtr & pv, std::size_t offset, std::size_t length,
         const uint16* from, std::size_t fromOffset);
     std::size_t fromUShortArray(
-        PVScalarArrayPtr const & pv, std::size_t offset, std::size_t length,
+        PVScalarArrayPtr & pv, std::size_t offset, std::size_t length,
         const UShortArray & from, std::size_t fromOffset);
     /**
      * Convert a PV array from an uint array.
@@ -641,10 +690,10 @@ public:
      * @throws std::invalid_argument if the element type is not numeric
      */
     std::size_t fromUIntArray(
-        PVScalarArrayPtr const & pv, std::size_t offset, std::size_t length,
+        PVScalarArrayPtr & pv, std::size_t offset, std::size_t length,
         const uint32* from, std::size_t fromOffset);
     std::size_t fromUIntArray(
-        PVScalarArrayPtr const & pv, std::size_t offset, std::size_t length,
+        PVScalarArrayPtr & pv, std::size_t offset, std::size_t length,
         const UIntArray & from, std::size_t fromOffset);
     /**
      * Convert a PV array from a ulong array.
@@ -657,10 +706,10 @@ public:
      * @throws std::invalid_argument if the element type is not numeric
      */
     std::size_t fromULongArray(
-        PVScalarArrayPtr const & pv, std::size_t offset, std::size_t length,
+        PVScalarArrayPtr & pv, std::size_t offset, std::size_t length,
         const uint64* from, std::size_t fromOffset);
     std::size_t fromULongArray(
-        PVScalarArrayPtr const & pv, std::size_t offset, std::size_t length,
+        PVScalarArrayPtr & pv, std::size_t offset, std::size_t length,
         const ULongArray & from, std::size_t fromOffset);
     /**
      * Convert a PV array from a float array.
@@ -673,10 +722,10 @@ public:
      * @throws std::invalid_argument if the element type is not numeric
      */
     std::size_t fromFloatArray(
-        PVScalarArrayPtr const & pv, std::size_t offset, std::size_t length,
+        PVScalarArrayPtr & pv, std::size_t offset, std::size_t length,
         const float* from, std::size_t fromOffset);
     std::size_t fromFloatArray(
-        PVScalarArrayPtr const & pv, std::size_t offset, std::size_t length,
+        PVScalarArrayPtr & pv, std::size_t offset, std::size_t length,
         const FloatArray & from, std::size_t fromOffset);
     /**
      * Convert a PV array from a double array.
@@ -689,10 +738,10 @@ public:
      * @throws std::invalid_argument if the element type is not numeric
      */
     std::size_t fromDoubleArray(
-        PVScalarArrayPtr const & pv, std::size_t offset, std::size_t length,
+        PVScalarArrayPtr & pv, std::size_t offset, std::size_t length,
         const double* from, std::size_t fromOffset);
     std::size_t fromDoubleArray(
-        PVScalarArrayPtr const & pv, std::size_t offset, std::size_t length,
+        PVScalarArrayPtr & pv, std::size_t offset, std::size_t length,
         const DoubleArray & from, std::size_t fromOffset);
     /**
      * Convenience method for implementing toString.
diff --git a/pvDataApp/pv/pvData.h b/pvDataApp/pv/pvData.h
index 4975f15..9b9eb92 100644
--- a/pvDataApp/pv/pvData.h
+++ b/pvDataApp/pv/pvData.h
@@ -161,7 +161,7 @@ public:
      * Get the fieldName for this field.
      * @return The name or empty string if top level field.
      */
-    String getFieldName();
+    String getFieldName() const ;
     /**
      * Register the message requester.
      * At most one requester can be registered.
@@ -176,19 +176,19 @@ public:
      * The other offsets are determined by recursively traversing each structure of the tree.
      * @return The offset.
      */
-    std::size_t getFieldOffset() ;
+    std::size_t getFieldOffset() const;
     /**
      * Get the next offset. If the field is a scalar or array field then this is just offset + 1.
      * If the field is a structure it is the offset of the next field after this structure.
      * Thus (nextOffset - offset) is always equal to the number of fields within the field.
      * @return The offset.
      */
-    std::size_t getNextFieldOffset() ;
+    std::size_t getNextFieldOffset() const;
     /**
      * Get the total number of fields in this field.
      * This is equal to nextFieldOffset - fieldOffset.
      */
-    std::size_t getNumberFields() ;
+    std::size_t getNumberFields() const;
     /**
      * Get the PVAuxInfo interface for the PVField.
      * @return The PVAuxInfo interface.
@@ -198,7 +198,7 @@ public:
      * Is the field immutable, i.e. does it not allow changes.
      * @return (false,true) if it (is not, is) immutable.
      */
-    bool isImmutable() ;
+    bool isImmutable() const;
     /**
      * Set the field to be immutable, i. e. it can no longer be modified.
      * This is permanent, i.e. once done the field can onot be made mutable.
@@ -208,17 +208,17 @@ public:
      * Get the <i>Field</i> that describes the field.
      * @return Field, which is the reflection interface.
      */
-    FieldConstPtr & getField() ;
+    const FieldConstPtr & getField() const ;
     /**
      * Get the parent of this field.
      * @return The parent interface or null if this is PVRecord
      */
-    PVStructure * getParent() ;
+    PVStructure * getParent() const ;
     /**
      * Replace the data implementation for the field.
      * @param newPVField The new implementation
      */
-    void replacePVField(PVFieldPtr&  newPVField);
+    void replacePVField(const PVFieldPtr&  newPVField);
     /**
      * Rename the field name.
      * @param newName The new name.
@@ -258,8 +258,8 @@ protected:
     void replaceField(FieldConstPtr &field);
 private:
     void message(String fieldName,String message,MessageType messageType);
-    static void computeOffset(PVField *pvField);
-    static void computeOffset(PVField *pvField,std::size_t offset);
+    static void computeOffset(const PVField *pvField);
+    static void computeOffset(const PVField *pvField,std::size_t offset);
     PVAuxInfoPtr pvAuxInfo;
     String fieldName;
     PVStructure *parent;
@@ -290,7 +290,7 @@ public:
      * Get the Scalar introspection interface for the PVScalar.
      * @return the interface.
      */
-    ScalarConstPtr getScalar() ;
+    const ScalarConstPtr getScalar() const ;
 protected:
     PVScalar(ScalarConstPtr const & scalar);
 };
@@ -313,7 +313,7 @@ public:
      * Get the value.
      * @return The value.
      */
-    virtual T get() = 0;
+    virtual T get() const = 0;
     /**
      * Put a new value into the PVScalar.
      * @param The value.
@@ -397,7 +397,7 @@ public:
      * Can the capacity be changed.
      * @return (false,true) if (can not, can) be changed.
      */
-    bool isCapacityMutable();
+    bool isCapacityMutable() const;
     /**
      * Set the mutability of the array capacity.
      * @return false or true
@@ -458,7 +458,7 @@ public:
      * Get the introspection interface
      * @return The interface.
      */
-    ScalarArrayConstPtr getScalarArray() ;
+    const ScalarArrayConstPtr getScalarArray() const ;
 
 protected:
     PVScalarArray(ScalarArrayConstPtr const & scalarArray);
@@ -495,7 +495,7 @@ public:
      * Get the introspection interface
      * @return The interface.
      */
-    virtual StructureArrayConstPtr getStructureArray();
+    virtual StructureArrayConstPtr getStructureArray() const ;
     /**
      * Append new elements to the end of the array.
      * @param number The number of elements to add.
@@ -574,24 +574,24 @@ public:
      * Get the introspection interface
      * @return The interface.
      */
-    StructureConstPtr &  getStructure();
+    StructureConstPtr getStructure() const;
     /**
      * Get the array of pointers to the subfields in the structure.
      * @return The array.
      */
-    PVFieldPtrArray & getPVFields();
+    const PVFieldPtrArray & getPVFields() const;
     /**
      * Get the subfield with the specified name.
      * @param fieldName The name of the field.
      * @return Pointer to the field or null if field does not exist.
      */
-    PVFieldPtr getSubField(String fieldName);
+    PVFieldPtr getSubField(String fieldName) const;
     /**
      * Get the subfield with the specified offset.
      * @param fieldOffset The offset.
      * @return Pointer to the field or null if field does not exist.
      */
-    PVFieldPtr getSubField(std::size_t fieldOffset);
+    PVFieldPtr getSubField(std::size_t fieldOffset) const;
     /**
      * Append a field to the structure.
      * @param fieldName The name of the field to append.
@@ -615,79 +615,79 @@ public:
      * @param fieldName The name of the field to get.
      * @return Pointer to the field of null if a field with that name and type does not exist.
      */
-    PVBooleanPtr getBooleanField(String fieldName);
+    PVBooleanPtr getBooleanField(String fieldName) ;
     /**
      * Get a byte field with the specified name.
      * @param fieldName The name of the field to get.
      * @return Pointer to the field of null if a field with that name and type does not exist.
      */
-    PVBytePtr getByteField(String fieldName);
+    PVBytePtr getByteField(String fieldName) ;
     /**
      * Get a short field with the specified name.
      * @param fieldName The name of the field to get.
      * @return Pointer to the field of null if a field with that name and type does not exist.
      */
-    PVShortPtr getShortField(String fieldName);
+    PVShortPtr getShortField(String fieldName) ;
     /**
      * Get a int field with the specified name.
      * @param fieldName The name of the field to get.
      * @return Pointer to the field of null if a field with that name and type does not exist.
      */
-    PVIntPtr getIntField(String fieldName);
+    PVIntPtr getIntField(String fieldName) ;
     /**
      * Get a long field with the specified name.
      * @param fieldName The name of the field to get.
      * @return Pointer to the field of null if a field with that name and type does not exist.
      */
-    PVLongPtr getLongField(String fieldName);
+    PVLongPtr getLongField(String fieldName) ;
     /**
      * Get an unsigned byte field with the specified name.
      * @param fieldName The name of the field to get.
      * @return Pointer to the field of null if a field with that name and type does not exist.
      */
-    PVUBytePtr getUByteField(String fieldName);
+    PVUBytePtr getUByteField(String fieldName) ;
     /**
      * Get an unsigned short field with the specified name.
      * @param fieldName The name of the field to get.
      * @return Pointer to the field of null if a field with that name and type does not exist.
      */
-    PVUShortPtr getUShortField(String fieldName);
+    PVUShortPtr getUShortField(String fieldName) ;
     /**
      * Get an unsigned int field with the specified name.
      * @param fieldName The name of the field to get.
      * @return Pointer to the field of null if a field with that name and type does not exist.
      */
-    PVUIntPtr getUIntField(String fieldName);
+    PVUIntPtr getUIntField(String fieldName) ;
     /**
      * Get an unsigned long field with the specified name.
      * @param fieldName The name of the field to get.
      * @return Pointer to the field of null if a field with that name and type does not exist.
      */
-    PVULongPtr getULongField(String fieldName);
+    PVULongPtr getULongField(String fieldName) ;
     /**
      * Get a float field with the specified name.
      * @param fieldName The name of the field to get.
      * @return Pointer to the field of null if a field with that name and type does not exist.
      */
-    PVFloatPtr getFloatField(String fieldName);
+    PVFloatPtr getFloatField(String fieldName) ;
     /**
      * Get a double field with the specified name.
      * @param fieldName The name of the field to get.
      * @return Pointer to the field of null if a field with that name and type does not exist.
      */
-    PVDoublePtr getDoubleField(String fieldName);
+    PVDoublePtr getDoubleField(String fieldName) ;
     /**
      * Get a string field with the specified name.
      * @param fieldName The name of the field to get.
      * @return Pointer to the field of null if a field with that name and type does not exist.
      */
-    PVStringPtr getStringField(String fieldName);
+    PVStringPtr getStringField(String fieldName) ;
     /**
      * Get a structure field with the specified name.
      * @param fieldName The name of the field to get.
      * @return Pointer to the field of null if a field with that name and type does not exist.
      */
-    PVStructurePtr getStructureField(String fieldName);
+    PVStructurePtr getStructureField(String fieldName) ;
     /**
      * Get a scalarArray field with the specified name.
      * @param fieldName The name of the field to get.
@@ -695,18 +695,18 @@ public:
      * @return Pointer to the field of null if a field with that name and type does not exist.
      */
     PVScalarArrayPtr getScalarArrayField(
-        String fieldName,ScalarType elementType);
+        String fieldName,ScalarType elementType) ;
     /**
      * Get a structureArray field with the specified name.
      * @param fieldName The name of the field to get.
      * @return Pointer to the field of null if a field with that name and type does not exist.
      */
-    PVStructureArrayPtr getStructureArrayField(String fieldName);
+    PVStructureArrayPtr getStructureArrayField(String fieldName) ;
     /**
      * Get the name if this structure extends another structure.
      * @return The string which may be null.
      */
-    String getExtendsStructureName();
+    String getExtendsStructureName() const;
     /**
      * Put the extends name.
      * @param extendsStructureName The name.
@@ -732,7 +732,7 @@ public:
      * @param pbuffer The byte buffer.
      * @param pflusher Interface to call when buffer is full.
      * @param pbitSet A bitset the specifies which fields to serialize.
-     */
+    */
     virtual void serialize(ByteBuffer *pbuffer,
         SerializableControl *pflusher,BitSet *pbitSet) const;
     /**
@@ -755,7 +755,7 @@ public:
      */
     PVStructure(StructureConstPtr const & structure,PVFieldPtrArray const & pvFields);
 private:
-    PVFieldPtrArray pvFields;
+    const PVFieldPtrArray pvFields;
     StructureConstPtr structurePtr;
     String extendsStructureName;
     friend class PVDataCreate;
diff --git a/testApp/pv/testPVAppend.cpp b/testApp/pv/testPVAppend.cpp
index 01fcdee..0f2c4b4 100644
--- a/testApp/pv/testPVAppend.cpp
+++ b/testApp/pv/testPVAppend.cpp
@@ -66,6 +66,7 @@ static void checkNameAndParent(
 
 static void testAppendSimple(FILE * fd)
 {
+    printf("\ntestAppendSimple\n");
     PVFieldPtrArray fields;
     StringArray names;
     PVStructurePtr pvParent = pvDataCreate->createPVStructure(names,fields);
@@ -86,6 +87,7 @@ static void testAppendSimple(FILE * fd)
 
 static void testAppendMore(FILE * fd)
 {
+    printf("\ntestAppendMore\n");
     PVFieldPtrArray fields;
     StringArray names;
     PVStructurePtr pvStructure = pvDataCreate->createPVStructure(names,fields);
@@ -111,7 +113,7 @@ static void testAppendMore(FILE * fd)
     checkNameAndParent(fd,pvStructure,0);
 }
 
-static void append2(PVStructurePtr pvStructure,
+static void append2(PVStructurePtr &pvStructure,
     const char *oneName,const char *twoName,
     const char *oneValue,const char *twoValue)
 {
@@ -133,6 +135,7 @@ static void append2(PVStructurePtr pvStructure,
 }
 static void testAppends(FILE * fd)
 {
+    printf("\ntestAppends\n");
     PVFieldPtrArray emptyPVFields;
     StringArray emptyNames;
     PVFieldPtrArray pvFields;