diff --git a/pvDataApp/factory/AbstractPVArray.h b/pvDataApp/factory/AbstractPVArray.h
index fd16164..2bbd096 100644
--- a/pvDataApp/factory/AbstractPVArray.h
+++ b/pvDataApp/factory/AbstractPVArray.h
@@ -35,6 +35,7 @@ namespace epics { namespace pvData {
      static String fieldImmutable("field is immutable");
 
      void PVArray::setLength(int length) {
+        if(length==pImpl->length) return;
         if(PVField::isImmutable()) {
            PVField::message(fieldImmutable,errorMessage);
            return;
@@ -44,8 +45,13 @@ namespace epics { namespace pvData {
         pImpl->length = length;
      }
 
+     void PVArray::setCapacityLength(int capacity,int length) {
+        pImpl->capacity = capacity;
+        pImpl->length = length;
+     }
 
-     epicsBoolean PVArray::isCapacityImmutable() 
+
+     epicsBoolean PVArray::isCapacityMutable() 
      {
           if(PVField::isImmutable()) {
               return epicsFalse;
@@ -53,7 +59,7 @@ namespace epics { namespace pvData {
           return pImpl->capacityMutable;
      }
 
-     void PVArray::setCapacityImmutable(epicsBoolean isMutable)
+     void PVArray::setCapacityMutable(epicsBoolean isMutable)
      {
         if(isMutable && PVField::isImmutable()) {
            PVField::message(fieldImmutable,errorMessage);
@@ -76,12 +82,5 @@ namespace epics { namespace pvData {
         pImpl->capacity = capacity;
      }
 
-     void PVArray::toString(StringBuilder buf)  {toString(buf,0);}
-
-     void PVArray::toString(StringBuilder buf, int indentLevel) 
-     {
-        throw std::logic_error(notImplemented);
-     }
-
 }}
 #endif  /* ABSTRACTPVARRAY_H */
diff --git a/pvDataApp/factory/AbstractPVField.h b/pvDataApp/factory/AbstractPVField.h
index 5a6cd03..24c9cbf 100644
--- a/pvDataApp/factory/AbstractPVField.h
+++ b/pvDataApp/factory/AbstractPVField.h
@@ -126,7 +126,7 @@ static String notImplemented("not implemented");
 
      void PVField::postPut() 
      {
-        throw std::logic_error(notImplemented);
+        if(pImpl->postHandler!=0) pImpl->postHandler->postPut();
      }
 
      void PVField::setPostHandler(PostHandler *ppostHandler)
diff --git a/pvDataApp/factory/BasePVBooleanArray.h b/pvDataApp/factory/BasePVBooleanArray.h
new file mode 100644
index 0000000..ba36fa3
--- /dev/null
+++ b/pvDataApp/factory/BasePVBooleanArray.h
@@ -0,0 +1,153 @@
+/*BasePVBooleanArrray.h*/
+#ifndef BASEPVBOOLEANARRAY_H
+#define BASEPVBOOLEANARRAY_H
+#include <cstddef>
+#include <cstdlib>
+#include <string>
+#include <cstdio>
+#include <epicsTypes.h>
+#include "pvData.h"
+#include "factory.h"
+#include "AbstractPVScalarArray.h"
+
+namespace epics { namespace pvData {
+
+    PVBooleanArray::~PVBooleanArray() {}
+
+    PVBooleanArray::PVBooleanArray(PVStructure *parent,ScalarArrayConstPtr scalar)
+    : PVScalarArray(parent,scalar) {}
+
+    class BasePVBooleanArray : public PVBooleanArray {
+    public:
+        BasePVBooleanArray(PVStructure *parent,ScalarArrayConstPtr scalarArray);
+        virtual ~BasePVBooleanArray();
+        virtual void setCapacity(int capacity);
+        virtual int get(int offset, int length, BooleanArrayData *data) ;
+        virtual int put(int offset,int length,BooleanArray from,
+           int fromOffset);
+        virtual void shareData(epicsBoolean value[],int capacity,int length);
+        // from Serializable
+        virtual void serialize(ByteBuffer *pbuffer,SerializableControl *pflusher) ;
+        virtual void deserialize(ByteBuffer *pbuffer,DeserializableControl *pflusher);
+        virtual void serialize(ByteBuffer *pbuffer,
+             SerializableControl *pflusher, int offset, int count) ;
+        virtual void toString(StringBuilder buf);
+        virtual void toString(StringBuilder buf,int indentLevel);
+        virtual epicsBoolean equals(PVField  *pv) ;
+    private:
+        epicsBoolean *value;
+    };
+
+    BasePVBooleanArray::BasePVBooleanArray(PVStructure *parent,
+        ScalarArrayConstPtr scalarArray)
+    : PVBooleanArray(parent,scalarArray),value(new epicsBoolean[0])
+    { } 
+
+    BasePVBooleanArray::~BasePVBooleanArray()
+    {
+        delete[] value;
+    }
+
+    void BasePVBooleanArray::setCapacity(int capacity)
+    {
+        if(PVArray::getCapacity()==capacity) return;
+        if(!PVArray::isCapacityMutable()) {
+            std::string message("not capacityMutable");
+            PVField::message(message, errorMessage);
+            return;
+        }
+        int length = PVArray::getLength();
+        if(length>capacity) length = capacity;
+        epicsBoolean *newValue = new epicsBoolean[capacity]; 
+        for(int i=0; i<length; i++) newValue[i] = value[i];
+        delete[]value;
+        value = newValue;
+        PVArray::setCapacityLength(capacity,length);
+    }
+
+    int BasePVBooleanArray::get(int offset, int len, BooleanArrayData *data) 
+    {
+        int n = len;
+        int length = PVArray::getLength();
+        if(offset+len > length) {
+            n = length-offset;
+            if(n<0) n = 0;
+        }
+        data->data = value;
+        data->offset = offset;
+        return n;
+    }
+
+    int BasePVBooleanArray::put(int offset,int len,
+        BooleanArray from,int fromOffset)
+    {
+        if(PVField::isImmutable()) {
+            PVField::message("field is immutable",errorMessage);
+            return 0;
+        }
+        if(from==value) return len;
+        if(len<1) return 0;
+        int length = PVArray::getLength();
+        int capacity = PVArray::getCapacity();
+        if(offset+len > length) {
+            int newlength = offset + len;
+            if(newlength>capacity) {
+                setCapacity(newlength);
+                newlength = PVArray::getCapacity();
+                len = newlength - offset;
+                if(len<=0) return 0;
+            }
+            length = newlength;
+        }
+        for(int i=0;i<len;i++) {
+           value[i+offset] = from[i+fromOffset];
+        }
+        PVArray::setLength(length);
+        PVField::postPut();
+        return len;      
+    }
+
+    void BasePVBooleanArray::shareData(
+        epicsBoolean shareValue[],int capacity,int length)
+    {
+        delete[] value;
+        value = shareValue;
+        PVArray::setCapacityLength(capacity,length);
+    }
+
+    void BasePVBooleanArray::serialize(ByteBuffer *pbuffer,
+         SerializableControl *pflusher) 
+    {
+        throw std::logic_error(notImplemented);
+    }
+
+    void BasePVBooleanArray::deserialize(ByteBuffer *pbuffer,
+         DeserializableControl *pflusher)
+    {
+        throw std::logic_error(notImplemented);
+    }
+
+    void BasePVBooleanArray::serialize(ByteBuffer *pbuffer,
+         SerializableControl *pflusher, int offset, int count) 
+    {
+        throw std::logic_error(notImplemented);
+    }
+
+    void BasePVBooleanArray::toString(StringBuilder buf)
+    {
+        toString(buf,1);
+    }
+
+    void BasePVBooleanArray::toString(StringBuilder buf,int indentLevel)
+    {
+        getConvert()->getString(buf,this,indentLevel);
+
+        PVField::toString(buf,indentLevel);
+    }
+
+    epicsBoolean BasePVBooleanArray::equals(PVField  *pv) 
+    {
+        return getConvert()->equals(this,pv);
+    }
+}}
+#endif  /* BASEPVBOOLEANARRAY_H */
diff --git a/pvDataApp/factory/BasePVByteArray.h b/pvDataApp/factory/BasePVByteArray.h
new file mode 100644
index 0000000..8302cbe
--- /dev/null
+++ b/pvDataApp/factory/BasePVByteArray.h
@@ -0,0 +1,153 @@
+/*BasePVByteArray.h*/
+#ifndef BASEPVBYTEARRAY_H
+#define BASEPVBYTEARRAY_H
+#include <cstddef>
+#include <cstdlib>
+#include <string>
+#include <cstdio>
+#include <epicsTypes.h>
+#include "pvData.h"
+#include "factory.h"
+#include "AbstractPVScalarArray.h"
+
+namespace epics { namespace pvData {
+
+    PVByteArray::~PVByteArray() {}
+
+    PVByteArray::PVByteArray(PVStructure *parent,ScalarArrayConstPtr scalar)
+    : PVScalarArray(parent,scalar) {}
+
+    class BasePVByteArray : public PVByteArray {
+    public:
+        BasePVByteArray(PVStructure *parent,ScalarArrayConstPtr scalarArray);
+        virtual ~BasePVByteArray();
+        virtual void setCapacity(int capacity);
+        virtual int get(int offset, int length, ByteArrayData *data) ;
+        virtual int put(int offset,int length,ByteArray from,
+           int fromOffset);
+        virtual void shareData(epicsInt8 value[],int capacity,int length);
+        // from Serializable
+        virtual void serialize(ByteBuffer *pbuffer,SerializableControl *pflusher) ;
+        virtual void deserialize(ByteBuffer *pbuffer,DeserializableControl *pflusher);
+        virtual void serialize(ByteBuffer *pbuffer,
+             SerializableControl *pflusher, int offset, int count) ;
+        virtual void toString(StringBuilder buf);
+        virtual void toString(StringBuilder buf,int indentLevel);
+        virtual epicsBoolean equals(PVField  *pv) ;
+    private:
+        epicsInt8 *value;
+    };
+
+    BasePVByteArray::BasePVByteArray(PVStructure *parent,
+        ScalarArrayConstPtr scalarArray)
+    : PVByteArray(parent,scalarArray),value(new epicsInt8[0])
+    { } 
+
+    BasePVByteArray::~BasePVByteArray()
+    {
+        delete[] value;
+    }
+
+    void BasePVByteArray::setCapacity(int capacity)
+    {
+        if(PVArray::getCapacity()==capacity) return;
+        if(!PVArray::isCapacityMutable()) {
+            std::string message("not capacityMutable");
+            PVField::message(message, errorMessage);
+            return;
+        }
+        int length = PVArray::getLength();
+        if(length>capacity) length = capacity;
+        epicsInt8 *newValue = new epicsInt8[capacity]; 
+        for(int i=0; i<length; i++) newValue[i] = value[i];
+        delete[]value;
+        value = newValue;
+        PVArray::setCapacityLength(capacity,length);
+    }
+
+    int BasePVByteArray::get(int offset, int len, ByteArrayData *data) 
+    {
+        int n = len;
+        int length = PVArray::getLength();
+        if(offset+len > length) {
+            n = length-offset;
+            if(n<0) n = 0;
+        }
+        data->data = value;
+        data->offset = offset;
+        return n;
+    }
+
+    int BasePVByteArray::put(int offset,int len,
+        ByteArray from,int fromOffset)
+    {
+        if(PVField::isImmutable()) {
+            PVField::message("field is immutable",errorMessage);
+            return 0;
+        }
+        if(from==value) return len;
+        if(len<1) return 0;
+        int length = PVArray::getLength();
+        int capacity = PVArray::getCapacity();
+        if(offset+len > length) {
+            int newlength = offset + len;
+            if(newlength>capacity) {
+                setCapacity(newlength);
+                newlength = PVArray::getCapacity();
+                len = newlength - offset;
+                if(len<=0) return 0;
+            }
+            length = newlength;
+        }
+        for(int i=0;i<len;i++) {
+           value[i+offset] = from[i+fromOffset];
+        }
+        PVArray::setLength(length);
+        PVField::postPut();
+        return len;      
+    }
+
+    void BasePVByteArray::shareData(
+        epicsInt8 shareValue[],int capacity,int length)
+    {
+        delete[] value;
+        value = shareValue;
+        PVArray::setCapacityLength(capacity,length);
+    }
+
+    void BasePVByteArray::serialize(ByteBuffer *pbuffer,
+         SerializableControl *pflusher) 
+    {
+        throw std::logic_error(notImplemented);
+    }
+
+    void BasePVByteArray::deserialize(ByteBuffer *pbuffer,
+         DeserializableControl *pflusher)
+    {
+        throw std::logic_error(notImplemented);
+    }
+
+    void BasePVByteArray::serialize(ByteBuffer *pbuffer,
+         SerializableControl *pflusher, int offset, int count) 
+    {
+        throw std::logic_error(notImplemented);
+    }
+
+    void BasePVByteArray::toString(StringBuilder buf)
+    {
+        toString(buf,1);
+    }
+
+    void BasePVByteArray::toString(StringBuilder buf,int indentLevel)
+    {
+        getConvert()->getString(buf,this,indentLevel);
+
+        PVField::toString(buf,indentLevel);
+    }
+
+    epicsBoolean BasePVByteArray::equals(PVField  *pv) 
+    {
+        return getConvert()->equals(this,pv);
+    }
+}}
+#endif  /* BASEPVBYTEARRAY_H */
diff --git a/pvDataApp/factory/BasePVDoubleArray.h b/pvDataApp/factory/BasePVDoubleArray.h
index 31df70a..1882e04 100644
--- a/pvDataApp/factory/BasePVDoubleArray.h
+++ b/pvDataApp/factory/BasePVDoubleArray.h
@@ -25,7 +25,7 @@ namespace epics { namespace pvData {
         virtual int get(int offset, int length, DoubleArrayData *data) ;
         virtual int put(int offset,int length,DoubleArray from,
            int fromOffset);
-        virtual void shareData(DoubleArrayData *from);
+        virtual void shareData(double value[],int capacity,int length);
         // from Serializable
         virtual void serialize(ByteBuffer *pbuffer,SerializableControl *pflusher) ;
         virtual void deserialize(ByteBuffer *pbuffer,DeserializableControl *pflusher);
@@ -35,40 +35,84 @@ namespace epics { namespace pvData {
         virtual void toString(StringBuilder buf,int indentLevel);
         virtual epicsBoolean equals(PVField  *pv) ;
     private:
-        double *doubleArray;
+        double *value;
     };
 
     BasePVDoubleArray::BasePVDoubleArray(PVStructure *parent,
         ScalarArrayConstPtr scalarArray)
-    : PVDoubleArray(parent,scalarArray),doubleArray(new double[0])
+    : PVDoubleArray(parent,scalarArray),value(new double[0])
     { } 
 
     BasePVDoubleArray::~BasePVDoubleArray()
     {
-        delete[] doubleArray;
+        delete[] value;
     }
 
     void BasePVDoubleArray::setCapacity(int capacity)
     {
-        throw std::logic_error(notImplemented);
+        if(PVArray::getCapacity()==capacity) return;
+        if(!PVArray::isCapacityMutable()) {
+            std::string message("not capacityMutable");
+            PVField::message(message, errorMessage);
+            return;
+        }
+        int length = PVArray::getLength();
+        if(length>capacity) length = capacity;
+        double *newValue = new double[capacity]; 
+        for(int i=0; i<length; i++) newValue[i] = value[i];
+        delete[]value;
+        value = newValue;
+        PVArray::setCapacityLength(capacity,length);
     }
 
-    int BasePVDoubleArray::get(int offset, int length,
-        DoubleArrayData *data) 
+    int BasePVDoubleArray::get(int offset, int len, DoubleArrayData *data) 
     {
-        data->data = doubleArray;
-        return getLength();
+        int n = len;
+        int length = PVArray::getLength();
+        if(offset+len > length) {
+            n = length-offset;
+            if(n<0) n = 0;
+        }
+        data->data = value;
+        data->offset = offset;
+        return n;
     }
 
-    int BasePVDoubleArray::put(int offset,int length,
+    int BasePVDoubleArray::put(int offset,int len,
         DoubleArray from,int fromOffset)
     {
-        return getLength();
+        if(PVField::isImmutable()) {
+            PVField::message("field is immutable",errorMessage);
+            return 0;
+        }
+        if(from==value) return len;
+        if(len<1) return 0;
+        int length = PVArray::getLength();
+        int capacity = PVArray::getCapacity();
+        if(offset+len > length) {
+            int newlength = offset + len;
+            if(newlength>capacity) {
+                setCapacity(newlength);
+                newlength = PVArray::getCapacity();
+                len = newlength - offset;
+                if(len<=0) return 0;
+            }
+            length = newlength;
+        }
+        for(int i=0;i<len;i++) {
+           value[i+offset] = from[i+fromOffset];
+        }
+        PVArray::setLength(length);
+        PVField::postPut();
+        return len;      
     }
 
-    void BasePVDoubleArray::shareData(DoubleArrayData *from)
+    void BasePVDoubleArray::shareData(
+        double shareValue[],int capacity,int length)
     {
-        throw std::logic_error(notImplemented);
+        delete[] value;
+        value = shareValue;
+        PVArray::setCapacityLength(capacity,length);
     }
 
     void BasePVDoubleArray::serialize(ByteBuffer *pbuffer,
@@ -97,12 +141,13 @@ namespace epics { namespace pvData {
     void BasePVDoubleArray::toString(StringBuilder buf,int indentLevel)
     {
         getConvert()->getString(buf,this,indentLevel);
-        PVArray::toString(buf,indentLevel);
+
+        PVField::toString(buf,indentLevel);
     }
 
     epicsBoolean BasePVDoubleArray::equals(PVField  *pv) 
     {
-        throw std::logic_error(notImplemented);
+        return getConvert()->equals(this,pv);
     }
 }}
 #endif  /* BASEPVDOUBLEARRAY_H */
diff --git a/pvDataApp/factory/BasePVFloatArray.h b/pvDataApp/factory/BasePVFloatArray.h
new file mode 100644
index 0000000..0b8b9b6
--- /dev/null
+++ b/pvDataApp/factory/BasePVFloatArray.h
@@ -0,0 +1,153 @@
+/*BasePVFloatArray.h*/
+#ifndef BASEPVFLOATARRAY_H
+#define BASEPVFLOATARRAY_H
+#include <cstddef>
+#include <cstdlib>
+#include <string>
+#include <cstdio>
+#include <epicsTypes.h>
+#include "pvData.h"
+#include "factory.h"
+#include "AbstractPVScalarArray.h"
+
+namespace epics { namespace pvData {
+
+    PVFloatArray::~PVFloatArray() {}
+
+    PVFloatArray::PVFloatArray(PVStructure *parent,ScalarArrayConstPtr scalar)
+    : PVScalarArray(parent,scalar) {}
+
+    class BasePVFloatArray : public PVFloatArray {
+    public:
+        BasePVFloatArray(PVStructure *parent,ScalarArrayConstPtr scalarArray);
+        virtual ~BasePVFloatArray();
+        virtual void setCapacity(int capacity);
+        virtual int get(int offset, int length, FloatArrayData *data) ;
+        virtual int put(int offset,int length,FloatArray from,
+           int fromOffset);
+        virtual void shareData(float value[],int capacity,int length);
+        // from Serializable
+        virtual void serialize(ByteBuffer *pbuffer,SerializableControl *pflusher) ;
+        virtual void deserialize(ByteBuffer *pbuffer,DeserializableControl *pflusher);
+        virtual void serialize(ByteBuffer *pbuffer,
+             SerializableControl *pflusher, int offset, int count) ;
+        virtual void toString(StringBuilder buf);
+        virtual void toString(StringBuilder buf,int indentLevel);
+        virtual epicsBoolean equals(PVField  *pv) ;
+    private:
+        float *value;
+    };
+
+    BasePVFloatArray::BasePVFloatArray(PVStructure *parent,
+        ScalarArrayConstPtr scalarArray)
+    : PVFloatArray(parent,scalarArray),value(new float[0])
+    { } 
+
+    BasePVFloatArray::~BasePVFloatArray()
+    {
+        delete[] value;
+    }
+
+    void BasePVFloatArray::setCapacity(int capacity)
+    {
+        if(PVArray::getCapacity()==capacity) return;
+        if(!PVArray::isCapacityMutable()) {
+            std::string message("not capacityMutable");
+            PVField::message(message, errorMessage);
+            return;
+        }
+        int length = PVArray::getLength();
+        if(length>capacity) length = capacity;
+        float *newValue = new float[capacity]; 
+        for(int i=0; i<length; i++) newValue[i] = value[i];
+        delete[]value;
+        value = newValue;
+        PVArray::setCapacityLength(capacity,length);
+    }
+
+    int BasePVFloatArray::get(int offset, int len, FloatArrayData *data) 
+    {
+        int n = len;
+        int length = PVArray::getLength();
+        if(offset+len > length) {
+            n = length-offset;
+            if(n<0) n = 0;
+        }
+        data->data = value;
+        data->offset = offset;
+        return n;
+    }
+
+    int BasePVFloatArray::put(int offset,int len,
+        FloatArray from,int fromOffset)
+    {
+        if(PVField::isImmutable()) {
+            PVField::message("field is immutable",errorMessage);
+            return 0;
+        }
+        if(from==value) return len;
+        if(len<1) return 0;
+        int length = PVArray::getLength();
+        int capacity = PVArray::getCapacity();
+        if(offset+len > length) {
+            int newlength = offset + len;
+            if(newlength>capacity) {
+                setCapacity(newlength);
+                newlength = PVArray::getCapacity();
+                len = newlength - offset;
+                if(len<=0) return 0;
+            }
+            length = newlength;
+        }
+        for(int i=0;i<len;i++) {
+           value[i+offset] = from[i+fromOffset];
+        }
+        PVArray::setLength(length);
+        PVField::postPut();
+        return len;      
+    }
+
+    void BasePVFloatArray::shareData(
+        float shareValue[],int capacity,int length)
+    {
+        delete[] value;
+        value = shareValue;
+        PVArray::setCapacityLength(capacity,length);
+    }
+
+    void BasePVFloatArray::serialize(ByteBuffer *pbuffer,
+         SerializableControl *pflusher) 
+    {
+        throw std::logic_error(notImplemented);
+    }
+
+    void BasePVFloatArray::deserialize(ByteBuffer *pbuffer,
+         DeserializableControl *pflusher)
+    {
+        throw std::logic_error(notImplemented);
+    }
+
+    void BasePVFloatArray::serialize(ByteBuffer *pbuffer,
+         SerializableControl *pflusher, int offset, int count) 
+    {
+        throw std::logic_error(notImplemented);
+    }
+
+    void BasePVFloatArray::toString(StringBuilder buf)
+    {
+        toString(buf,1);
+    }
+
+    void BasePVFloatArray::toString(StringBuilder buf,int indentLevel)
+    {
+        getConvert()->getString(buf,this,indentLevel);
+
+        PVField::toString(buf,indentLevel);
+    }
+
+    epicsBoolean BasePVFloatArray::equals(PVField  *pv) 
+    {
+        return getConvert()->equals(this,pv);
+    }
+}}
+#endif  /* BASEPVFLOATARRAY_H */
diff --git a/pvDataApp/factory/BasePVIntArray.h b/pvDataApp/factory/BasePVIntArray.h
new file mode 100644
index 0000000..44fc10e
--- /dev/null
+++ b/pvDataApp/factory/BasePVIntArray.h
@@ -0,0 +1,153 @@
+/*BasePVIntArray.h*/
+#ifndef BASEPVINTARRAY_H
+#define BASEPVINTARRAY_H
+#include <cstddef>
+#include <cstdlib>
+#include <string>
+#include <cstdio>
+#include <epicsTypes.h>
+#include "pvData.h"
+#include "factory.h"
+#include "AbstractPVScalarArray.h"
+
+namespace epics { namespace pvData {
+
+    PVIntArray::~PVIntArray() {}
+
+    PVIntArray::PVIntArray(PVStructure *parent,ScalarArrayConstPtr scalar)
+    : PVScalarArray(parent,scalar) {}
+
+    class BasePVIntArray : public PVIntArray {
+    public:
+        BasePVIntArray(PVStructure *parent,ScalarArrayConstPtr scalarArray);
+        virtual ~BasePVIntArray();
+        virtual void setCapacity(int capacity);
+        virtual int get(int offset, int length, IntArrayData *data) ;
+        virtual int put(int offset,int length,IntArray from,
+           int fromOffset);
+        virtual void shareData(epicsInt32 value[],int capacity,int length);
+        // from Serializable
+        virtual void serialize(ByteBuffer *pbuffer,SerializableControl *pflusher) ;
+        virtual void deserialize(ByteBuffer *pbuffer,DeserializableControl *pflusher);
+        virtual void serialize(ByteBuffer *pbuffer,
+             SerializableControl *pflusher, int offset, int count) ;
+        virtual void toString(StringBuilder buf);
+        virtual void toString(StringBuilder buf,int indentLevel);
+        virtual epicsBoolean equals(PVField  *pv) ;
+    private:
+        epicsInt32 *value;
+    };
+
+    BasePVIntArray::BasePVIntArray(PVStructure *parent,
+        ScalarArrayConstPtr scalarArray)
+    : PVIntArray(parent,scalarArray),value(new epicsInt32[0])
+    { } 
+
+    BasePVIntArray::~BasePVIntArray()
+    {
+        delete[] value;
+    }
+
+    void BasePVIntArray::setCapacity(int capacity)
+    {
+        if(PVArray::getCapacity()==capacity) return;
+        if(!PVArray::isCapacityMutable()) {
+            std::string message("not capacityMutable");
+            PVField::message(message, errorMessage);
+            return;
+        }
+        int length = PVArray::getLength();
+        if(length>capacity) length = capacity;
+        epicsInt32 *newValue = new epicsInt32[capacity]; 
+        for(int i=0; i<length; i++) newValue[i] = value[i];
+        delete[]value;
+        value = newValue;
+        PVArray::setCapacityLength(capacity,length);
+    }
+
+    int BasePVIntArray::get(int offset, int len, IntArrayData *data) 
+    {
+        int n = len;
+        int length = PVArray::getLength();
+        if(offset+len > length) {
+            n = length-offset;
+            if(n<0) n = 0;
+        }
+        data->data = value;
+        data->offset = offset;
+        return n;
+    }
+
+    int BasePVIntArray::put(int offset,int len,
+        IntArray from,int fromOffset)
+    {
+        if(PVField::isImmutable()) {
+            PVField::message("field is immutable",errorMessage);
+            return 0;
+        }
+        if(from==value) return len;
+        if(len<1) return 0;
+        int length = PVArray::getLength();
+        int capacity = PVArray::getCapacity();
+        if(offset+len > length) {
+            int newlength = offset + len;
+            if(newlength>capacity) {
+                setCapacity(newlength);
+                newlength = PVArray::getCapacity();
+                len = newlength - offset;
+                if(len<=0) return 0;
+            }
+            length = newlength;
+        }
+        for(int i=0;i<len;i++) {
+           value[i+offset] = from[i+fromOffset];
+        }
+        PVArray::setLength(length);
+        PVField::postPut();
+        return len;      
+    }
+
+    void BasePVIntArray::shareData(
+        epicsInt32 shareValue[],int capacity,int length)
+    {
+        delete[] value;
+        value = shareValue;
+        PVArray::setCapacityLength(capacity,length);
+    }
+
+    void BasePVIntArray::serialize(ByteBuffer *pbuffer,
+         SerializableControl *pflusher) 
+    {
+        throw std::logic_error(notImplemented);
+    }
+
+    void BasePVIntArray::deserialize(ByteBuffer *pbuffer,
+         DeserializableControl *pflusher)
+    {
+        throw std::logic_error(notImplemented);
+    }
+
+    void BasePVIntArray::serialize(ByteBuffer *pbuffer,
+         SerializableControl *pflusher, int offset, int count) 
+    {
+        throw std::logic_error(notImplemented);
+    }
+
+    void BasePVIntArray::toString(StringBuilder buf)
+    {
+        toString(buf,1);
+    }
+
+    void BasePVIntArray::toString(StringBuilder buf,int indentLevel)
+    {
+        getConvert()->getString(buf,this,indentLevel);
+
+        PVField::toString(buf,indentLevel);
+    }
+
+    epicsBoolean BasePVIntArray::equals(PVField  *pv) 
+    {
+        return getConvert()->equals(this,pv);
+    }
+}}
+#endif  /* BASEPVINTARRAY_H */
diff --git a/pvDataApp/factory/BasePVLongArray.h b/pvDataApp/factory/BasePVLongArray.h
new file mode 100644
index 0000000..4864210
--- /dev/null
+++ b/pvDataApp/factory/BasePVLongArray.h
@@ -0,0 +1,153 @@
+/*BasePVLongArray.h*/
+#ifndef BASEPVLONGARRAY_H
+#define BASEPVLONGARRAY_H
+#include <cstddef>
+#include <cstdlib>
+#include <string>
+#include <cstdio>
+#include <epicsTypes.h>
+#include "pvData.h"
+#include "factory.h"
+#include "AbstractPVScalarArray.h"
+
+namespace epics { namespace pvData {
+
+    PVLongArray::~PVLongArray() {}
+
+    PVLongArray::PVLongArray(PVStructure *parent,ScalarArrayConstPtr scalar)
+    : PVScalarArray(parent,scalar) {}
+
+    class BasePVLongArray : public PVLongArray {
+    public:
+        BasePVLongArray(PVStructure *parent,ScalarArrayConstPtr scalarArray);
+        virtual ~BasePVLongArray();
+        virtual void setCapacity(int capacity);
+        virtual int get(int offset, int length, LongArrayData *data) ;
+        virtual int put(int offset,int length,LongArray from,
+           int fromOffset);
+        virtual void shareData(epicsInt64 value[],int capacity,int length);
+        // from Serializable
+        virtual void serialize(ByteBuffer *pbuffer,SerializableControl *pflusher) ;
+        virtual void deserialize(ByteBuffer *pbuffer,DeserializableControl *pflusher);
+        virtual void serialize(ByteBuffer *pbuffer,
+             SerializableControl *pflusher, int offset, int count) ;
+        virtual void toString(StringBuilder buf);
+        virtual void toString(StringBuilder buf,int indentLevel);
+        virtual epicsBoolean equals(PVField  *pv) ;
+    private:
+        epicsInt64 *value;
+    };
+
+    BasePVLongArray::BasePVLongArray(PVStructure *parent,
+        ScalarArrayConstPtr scalarArray)
+    : PVLongArray(parent,scalarArray),value(new epicsInt64[0])
+    { } 
+
+    BasePVLongArray::~BasePVLongArray()
+    {
+        delete[] value;
+    }
+
+    void BasePVLongArray::setCapacity(int capacity)
+    {
+        if(PVArray::getCapacity()==capacity) return;
+        if(!PVArray::isCapacityMutable()) {
+            std::string message("not capacityMutable");
+            PVField::message(message, errorMessage);
+            return;
+        }
+        int length = PVArray::getLength();
+        if(length>capacity) length = capacity;
+        epicsInt64 *newValue = new epicsInt64[capacity]; 
+        for(int i=0; i<length; i++) newValue[i] = value[i];
+        delete[]value;
+        value = newValue;
+        PVArray::setCapacityLength(capacity,length);
+    }
+
+    int BasePVLongArray::get(int offset, int len, LongArrayData *data) 
+    {
+        int n = len;
+        int length = PVArray::getLength();
+        if(offset+len > length) {
+            n = length-offset;
+            if(n<0) n = 0;
+        }
+        data->data = value;
+        data->offset = offset;
+        return n;
+    }
+
+    int BasePVLongArray::put(int offset,int len,
+        LongArray from,int fromOffset)
+    {
+        if(PVField::isImmutable()) {
+            PVField::message("field is immutable",errorMessage);
+            return 0;
+        }
+        if(from==value) return len;
+        if(len<1) return 0;
+        int length = PVArray::getLength();
+        int capacity = PVArray::getCapacity();
+        if(offset+len > length) {
+            int newlength = offset + len;
+            if(newlength>capacity) {
+                setCapacity(newlength);
+                newlength = PVArray::getCapacity();
+                len = newlength - offset;
+                if(len<=0) return 0;
+            }
+            length = newlength;
+        }
+        for(int i=0;i<len;i++) {
+           value[i+offset] = from[i+fromOffset];
+        }
+        PVArray::setLength(length);
+        PVField::postPut();
+        return len;      
+    }
+
+    void BasePVLongArray::shareData(
+        epicsInt64 shareValue[],int capacity,int length)
+    {
+        delete[] value;
+        value = shareValue;
+        PVArray::setCapacityLength(capacity,length);
+    }
+
+    void BasePVLongArray::serialize(ByteBuffer *pbuffer,
+         SerializableControl *pflusher) 
+    {
+        throw std::logic_error(notImplemented);
+    }
+
+    void BasePVLongArray::deserialize(ByteBuffer *pbuffer,
+         DeserializableControl *pflusher)
+    {
+        throw std::logic_error(notImplemented);
+    }
+
+    void BasePVLongArray::serialize(ByteBuffer *pbuffer,
+         SerializableControl *pflusher, int offset, int count) 
+    {
+        throw std::logic_error(notImplemented);
+    }
+
+    void BasePVLongArray::toString(StringBuilder buf)
+    {
+        toString(buf,1);
+    }
+
+    void BasePVLongArray::toString(StringBuilder buf,int indentLevel)
+    {
+        getConvert()->getString(buf,this,indentLevel);
+
+        PVField::toString(buf,indentLevel);
+    }
+
+    epicsBoolean BasePVLongArray::equals(PVField  *pv) 
+    {
+        return getConvert()->equals(this,pv);
+    }
+}}
+#endif  /* BASEPVLONGARRAY_H */
diff --git a/pvDataApp/factory/BasePVShortArray.h b/pvDataApp/factory/BasePVShortArray.h
new file mode 100644
index 0000000..46aa268
--- /dev/null
+++ b/pvDataApp/factory/BasePVShortArray.h
@@ -0,0 +1,153 @@
+/*BasePVShortArray.h*/
+#ifndef BASEPVSHORTARRAY_H
+#define BASEPVSHORTARRAY_H
+#include <cstddef>
+#include <cstdlib>
+#include <string>
+#include <cstdio>
+#include <epicsTypes.h>
+#include "pvData.h"
+#include "factory.h"
+#include "AbstractPVScalarArray.h"
+
+namespace epics { namespace pvData {
+
+    PVShortArray::~PVShortArray() {}
+
+    PVShortArray::PVShortArray(PVStructure *parent,ScalarArrayConstPtr scalar)
+    : PVScalarArray(parent,scalar) {}
+
+    class BasePVShortArray : public PVShortArray {
+    public:
+        BasePVShortArray(PVStructure *parent,ScalarArrayConstPtr scalarArray);
+        virtual ~BasePVShortArray();
+        virtual void setCapacity(int capacity);
+        virtual int get(int offset, int length, ShortArrayData *data) ;
+        virtual int put(int offset,int length,ShortArray from,
+           int fromOffset);
+        virtual void shareData(epicsInt16 value[],int capacity,int length);
+        // from Serializable
+        virtual void serialize(ByteBuffer *pbuffer,SerializableControl *pflusher) ;
+        virtual void deserialize(ByteBuffer *pbuffer,DeserializableControl *pflusher);
+        virtual void serialize(ByteBuffer *pbuffer,
+             SerializableControl *pflusher, int offset, int count) ;
+        virtual void toString(StringBuilder buf);
+        virtual void toString(StringBuilder buf,int indentLevel);
+        virtual epicsBoolean equals(PVField  *pv) ;
+    private:
+        epicsInt16 *value;
+    };
+
+    BasePVShortArray::BasePVShortArray(PVStructure *parent,
+        ScalarArrayConstPtr scalarArray)
+    : PVShortArray(parent,scalarArray),value(new epicsInt16[0])
+    { } 
+
+    BasePVShortArray::~BasePVShortArray()
+    {
+        delete[] value;
+    }
+
+    void BasePVShortArray::setCapacity(int capacity)
+    {
+        if(PVArray::getCapacity()==capacity) return;
+        if(!PVArray::isCapacityMutable()) {
+            std::string message("not capacityMutable");
+            PVField::message(message, errorMessage);
+            return;
+        }
+        int length = PVArray::getLength();
+        if(length>capacity) length = capacity;
+        epicsInt16 *newValue = new epicsInt16[capacity]; 
+        for(int i=0; i<length; i++) newValue[i] = value[i];
+        delete[]value;
+        value = newValue;
+        PVArray::setCapacityLength(capacity,length);
+    }
+
+    int BasePVShortArray::get(int offset, int len, ShortArrayData *data) 
+    {
+        int n = len;
+        int length = PVArray::getLength();
+        if(offset+len > length) {
+            n = length-offset;
+            if(n<0) n = 0;
+        }
+        data->data = value;
+        data->offset = offset;
+        return n;
+    }
+
+    int BasePVShortArray::put(int offset,int len,
+        ShortArray from,int fromOffset)
+    {
+        if(PVField::isImmutable()) {
+            PVField::message("field is immutable",errorMessage);
+            return 0;
+        }
+        if(from==value) return len;
+        if(len<1) return 0;
+        int length = PVArray::getLength();
+        int capacity = PVArray::getCapacity();
+        if(offset+len > length) {
+            int newlength = offset + len;
+            if(newlength>capacity) {
+                setCapacity(newlength);
+                newlength = PVArray::getCapacity();
+                len = newlength - offset;
+                if(len<=0) return 0;
+            }
+            length = newlength;
+        }
+        for(int i=0;i<len;i++) {
+           value[i+offset] = from[i+fromOffset];
+        }
+        PVArray::setLength(length);
+        PVField::postPut();
+        return len;      
+    }
+
+    void BasePVShortArray::shareData(
+        epicsInt16 shareValue[],int capacity,int length)
+    {
+        delete[] value;
+        value = shareValue;
+        PVArray::setCapacityLength(capacity,length);
+    }
+
+    void BasePVShortArray::serialize(ByteBuffer *pbuffer,
+         SerializableControl *pflusher) 
+    {
+        throw std::logic_error(notImplemented);
+    }
+
+    void BasePVShortArray::deserialize(ByteBuffer *pbuffer,
+         DeserializableControl *pflusher)
+    {
+        throw std::logic_error(notImplemented);
+    }
+
+    void BasePVShortArray::serialize(ByteBuffer *pbuffer,
+         SerializableControl *pflusher, int offset, int count) 
+    {
+        throw std::logic_error(notImplemented);
+    }
+
+    void BasePVShortArray::toString(StringBuilder buf)
+    {
+        toString(buf,1);
+    }
+
+    void BasePVShortArray::toString(StringBuilder buf,int indentLevel)
+    {
+        getConvert()->getString(buf,this,indentLevel);
+
+        PVField::toString(buf,indentLevel);
+    }
+
+    epicsBoolean BasePVShortArray::equals(PVField  *pv) 
+    {
+        return getConvert()->equals(this,pv);
+    }
+}}
+#endif  /* BASEPVSHORTARRAY_H */
diff --git a/pvDataApp/factory/BasePVStringArray.h b/pvDataApp/factory/BasePVStringArray.h
new file mode 100644
index 0000000..8c9daf5
--- /dev/null
+++ b/pvDataApp/factory/BasePVStringArray.h
@@ -0,0 +1,153 @@
+/*BasePVStringArray.h*/
+#ifndef BASEPVSTRINGARRAY_H
+#define BASEPVSTRINGARRAY_H
+#include <cstddef>
+#include <cstdlib>
+#include <string>
+#include <cstdio>
+#include <epicsTypes.h>
+#include "pvData.h"
+#include "factory.h"
+#include "AbstractPVScalarArray.h"
+
+namespace epics { namespace pvData {
+
+    PVStringArray::~PVStringArray() {}
+
+    PVStringArray::PVStringArray(PVStructure *parent,ScalarArrayConstPtr scalar)
+    : PVScalarArray(parent,scalar) {}
+
+    class BasePVStringArray : public PVStringArray {
+    public:
+        BasePVStringArray(PVStructure *parent,ScalarArrayConstPtr scalarArray);
+        virtual ~BasePVStringArray();
+        virtual void setCapacity(int capacity);
+        virtual int get(int offset, int length, StringArrayData *data) ;
+        virtual int put(int offset,int length,StringArray from,
+           int fromOffset);
+        virtual void shareData(String value[],int capacity,int length);
+        // from Serializable
+        virtual void serialize(ByteBuffer *pbuffer,SerializableControl *pflusher) ;
+        virtual void deserialize(ByteBuffer *pbuffer,DeserializableControl *pflusher);
+        virtual void serialize(ByteBuffer *pbuffer,
+             SerializableControl *pflusher, int offset, int count) ;
+        virtual void toString(StringBuilder buf);
+        virtual void toString(StringBuilder buf,int indentLevel);
+        virtual epicsBoolean equals(PVField  *pv) ;
+    private:
+        String *value;
+    };
+
+    BasePVStringArray::BasePVStringArray(PVStructure *parent,
+        ScalarArrayConstPtr scalarArray)
+    : PVStringArray(parent,scalarArray),value(new String[0])
+    { } 
+
+    BasePVStringArray::~BasePVStringArray()
+    {
+        delete[] value;
+    }
+
+    void BasePVStringArray::setCapacity(int capacity)
+    {
+        if(PVArray::getCapacity()==capacity) return;
+        if(!PVArray::isCapacityMutable()) {
+            std::string message("not capacityMutable");
+            PVField::message(message, errorMessage);
+            return;
+        }
+        int length = PVArray::getLength();
+        if(length>capacity) length = capacity;
+        String *newValue = new String[capacity]; 
+        for(int i=0; i<length; i++) newValue[i] = value[i];
+        delete[]value;
+        value = newValue;
+        PVArray::setCapacityLength(capacity,length);
+    }
+
+    int BasePVStringArray::get(int offset, int len, StringArrayData *data) 
+    {
+        int n = len;
+        int length = PVArray::getLength();
+        if(offset+len > length) {
+            n = length-offset;
+            if(n<0) n = 0;
+        }
+        data->data = value;
+        data->offset = offset;
+        return n;
+    }
+
+    int BasePVStringArray::put(int offset,int len,
+        StringArray from,int fromOffset)
+    {
+        if(PVField::isImmutable()) {
+            PVField::message("field is immutable",errorMessage);
+            return 0;
+        }
+        if(from==value) return len;
+        if(len<1) return 0;
+        int length = PVArray::getLength();
+        int capacity = PVArray::getCapacity();
+        if(offset+len > length) {
+            int newlength = offset + len;
+            if(newlength>capacity) {
+                setCapacity(newlength);
+                newlength = PVArray::getCapacity();
+                len = newlength - offset;
+                if(len<=0) return 0;
+            }
+            length = newlength;
+        }
+        for(int i=0;i<len;i++) {
+           value[i+offset] = from[i+fromOffset];
+        }
+        PVArray::setLength(length);
+        PVField::postPut();
+        return len;      
+    }
+
+    void BasePVStringArray::shareData(
+        String shareValue[],int capacity,int length)
+    {
+        delete[] value;
+        value = shareValue;
+        PVArray::setCapacityLength(capacity,length);
+    }
+
+    void BasePVStringArray::serialize(ByteBuffer *pbuffer,
+         SerializableControl *pflusher) 
+    {
+        throw std::logic_error(notImplemented);
+    }
+
+    void BasePVStringArray::deserialize(ByteBuffer *pbuffer,
+         DeserializableControl *pflusher)
+    {
+        throw std::logic_error(notImplemented);
+    }
+
+    void BasePVStringArray::serialize(ByteBuffer *pbuffer,
+         SerializableControl *pflusher, int offset, int count) 
+    {
+        throw std::logic_error(notImplemented);
+    }
+
+    void BasePVStringArray::toString(StringBuilder buf)
+    {
+        toString(buf,1);
+    }
+
+    void BasePVStringArray::toString(StringBuilder buf,int indentLevel)
+    {
+        getConvert()->getString(buf,this,indentLevel);
+
+        PVField::toString(buf,indentLevel);
+    }
+
+    epicsBoolean BasePVStringArray::equals(PVField  *pv) 
+    {
+        return getConvert()->equals(this,pv);
+    }
+}}
+#endif  /* BASEPVSTRINGARRAY_H */
diff --git a/pvDataApp/factory/BasePVStructure.h b/pvDataApp/factory/BasePVStructure.h
index 0c668bb..faec1ef 100644
--- a/pvDataApp/factory/BasePVStructure.h
+++ b/pvDataApp/factory/BasePVStructure.h
@@ -21,7 +21,7 @@ namespace epics { namespace pvData {
     };
 
     PVStructurePvt::PVStructurePvt()
-    : numberFields(0), pvFields(0),extendsStructureName(0)
+    : numberFields(0), pvFields(0),extendsStructureName("")
     {
     }
 
diff --git a/pvDataApp/factory/BasePVStructureArray.h b/pvDataApp/factory/BasePVStructureArray.h
index 32f9bf6..763b6de 100644
--- a/pvDataApp/factory/BasePVStructureArray.h
+++ b/pvDataApp/factory/BasePVStructureArray.h
@@ -62,7 +62,8 @@ namespace epics { namespace pvData {
         throw std::logic_error(notImplemented);
     }
 
-    void PVStructureArray::shareData(StructureArrayData *from)
+    void PVStructureArray::shareData(
+        PVStructurePtrArray value,int capacity,int length)
     {
         throw std::logic_error(notImplemented);
     }
diff --git a/pvDataApp/factory/Convert.cpp b/pvDataApp/factory/Convert.cpp
index c69bd65..22a9ca6 100644
--- a/pvDataApp/factory/Convert.cpp
+++ b/pvDataApp/factory/Convert.cpp
@@ -199,7 +199,7 @@ int Convert::fromString(PVScalarArray *pv, String from)
     int num = fromStringArray(pv,0,length,valueArray,0);
     if(num<length) length = num;
     pv->setLength(length);
-    delete valueArray;
+    delete[] valueArray;
     return length;
 }
 
@@ -995,7 +995,171 @@ void convertStructure(StringBuilder buffer,PVStructure *data,int indentLevel)
 
 void convertArray(StringBuilder buffer,PVScalarArray * pv,int indentLevel)
 {
-    throw std::logic_error(notImplemented);
+    ScalarArrayConstPtr array = pv->getScalarArray();
+    ScalarType type = array->getElementType();
+    switch(type) {
+    case pvBoolean: {
+            PVBooleanArray *pvdata = (PVBooleanArray*)pv;
+            BooleanArrayData data = BooleanArrayData();
+            *buffer += "[";
+            for(int i=0; i < pvdata->getLength(); i++) {
+                if(i!=0) *buffer += ",";
+                int num = pvdata->get(i,1,&data);
+                if(num==1) {
+                     epicsBoolean * value = data.data;
+                     if(value[data.offset]) {
+                         *buffer += "true";
+                     } else {
+                         *buffer += "false";
+                     }
+                } else {
+                     *buffer += "???? ";
+                }
+            }
+            *buffer += "]";
+            break;
+        }
+    case pvByte: {
+            PVByteArray *pvdata = (PVByteArray*)pv;
+            ByteArrayData data = ByteArrayData();
+            *buffer += "[";
+            for(int i=0; i < pvdata->getLength(); i++) {
+                if(i!=0) *buffer += ",";
+                int num = pvdata->get(i,1,&data);
+                if(num==1) {
+                     int val = data.data[data.offset];
+                     char buf[16];
+                     sprintf(buf,"%d",val);
+                     *buffer += buf;
+                } else {
+                     *buffer += "???? ";
+                }
+            }
+            *buffer += "]";
+            break;
+        }
+    case pvShort: {
+            PVShortArray *pvdata = (PVShortArray*)pv;
+            ShortArrayData data = ShortArrayData();
+            *buffer += "[";
+            for(int i=0; i < pvdata->getLength(); i++) {
+                if(i!=0) *buffer += ',';
+                int num = pvdata->get(i,1,&data);
+                if(num==1) {
+                     int val = data.data[data.offset];
+                     char buf[16];
+                     sprintf(buf,"%d",val);
+                     *buffer += buf;
+                } else {
+                     *buffer += "???? ";
+                }
+            }
+            *buffer += "]";
+            break;
+        }
+    case pvInt: {
+            PVIntArray *pvdata = (PVIntArray*)pv;
+            IntArrayData data = IntArrayData();
+            *buffer += "[";
+            for(int i=0; i < pvdata->getLength(); i++) {
+                if(i!=0) *buffer += ',';
+                int num = pvdata->get(i,1,&data);
+                if(num==1) {
+                     int val = data.data[data.offset];
+                     char buf[16];
+                     sprintf(buf,"%d",val);
+                     *buffer += buf;
+                } else {
+                     *buffer += "???? ";
+                }
+            }
+            *buffer += "]";
+            break;
+        }
+    case pvLong: {
+            PVLongArray *pvdata = (PVLongArray*)pv;
+            LongArrayData data = LongArrayData();
+            *buffer += "[";
+            for(int i=0; i < pvdata->getLength(); i++) {
+                if(i!=0) *buffer += ',';
+                int num = pvdata->get(i,1,&data);
+                if(num==1) {
+                     long int val = data.data[data.offset];
+                     char buf[16];
+                     sprintf(buf,"%ld",val);
+                     *buffer += buf;
+                } else {
+                     *buffer += "???? ";
+                }
+            }
+            *buffer += "]";
+            break;
+        }
+    case pvFloat: {
+            PVFloatArray *pvdata = (PVFloatArray*)pv;
+            FloatArrayData data = FloatArrayData();
+            *buffer += "[";
+            for(int i=0; i < pvdata->getLength(); i++) {
+                if(i!=0) *buffer += ',';
+                int num = pvdata->get(i,1,&data);
+                if(num==1) {
+                     float val = data.data[data.offset];
+                     char buf[16];
+                     sprintf(buf,"%f",val);
+                     *buffer += buf;
+                } else {
+                     *buffer += "???? ";
+                }
+            }
+            *buffer += "]";
+            break;
+        }
+    case pvDouble: {
+            PVDoubleArray *pvdata = (PVDoubleArray*)pv;
+            DoubleArrayData data = DoubleArrayData();
+            *buffer += "[";
+            for(int i=0; i < pvdata->getLength(); i++) {
+                if(i!=0) *buffer += ',';
+                int num = pvdata->get(i,1,&data);
+                if(num==1) {
+                     double val = data.data[data.offset];
+                     char buf[16];
+                     sprintf(buf,"%lf",val);
+                     *buffer += buf;
+                } else {
+                     *buffer += "???? ";
+                }
+            }
+            *buffer += ("]");
+            break;
+        }
+    case pvString: {
+    	PVStringArray *pvdata = (PVStringArray*)pv;
+    	StringArrayData data = StringArrayData();
+    	*buffer += "[";
+    	for(int i=0; i < pvdata->getLength(); i++) {
+    		if(i!=0) *buffer += ",";
+    		int num = pvdata->get(i,1,&data);
+    		StringPtrArray value = data.data;
+                if(num==1) {
+                    if(value[data.offset].length()>0) {
+                         *buffer += value[data.offset].c_str();
+                    } else {
+                         *buffer += "null";
+                    }
+    		} else {
+    			*buffer += "null";
+    		}
+    	}
+    	*buffer += "]";
+    	break;
+    }
+    default:
+        *buffer += " array element is unknown ScalarType";
+    }
+    if(pv->isImmutable()) {
+        *buffer += " immutable ";
+    }
 }
 
 void convertStructureArray(StringBuilder buffer,PVStructureArray * pvdata,int indentLevel)
@@ -1019,8 +1183,8 @@ public:
 };
 
 Convert * getConvert() {
-    static Mutex *mutex = new Mutex();
-    Lock xx(mutex);
+    static Mutex mutex = Mutex();
+    Lock xx(&mutex);
 
     if(convert==0){
         convert = new ConvertExt();
diff --git a/pvDataApp/factory/FieldCreateFactory.cpp b/pvDataApp/factory/FieldCreateFactory.cpp
index df9549b..35c5e88 100644
--- a/pvDataApp/factory/FieldCreateFactory.cpp
+++ b/pvDataApp/factory/FieldCreateFactory.cpp
@@ -110,7 +110,7 @@ namespace epics { namespace pvData {
 
     BaseScalarArray::BaseScalarArray
            (String fieldName,ScalarType elementType)
-           : BaseField(fieldName,scalar),elementType(elementType){}
+           : BaseField(fieldName,scalarArray),elementType(elementType){}
     BaseScalarArray::~BaseScalarArray() {}
 
 
@@ -305,8 +305,8 @@ namespace epics { namespace pvData {
    };
 
    FieldCreate * getFieldCreate() {
-       static Mutex *mutex = new Mutex();
-       Lock xx(mutex);
+       static Mutex mutex = Mutex();
+       Lock xx(&mutex);
 
        if(instance==0) instance = new FieldCreateExt();
        return instance;
diff --git a/pvDataApp/factory/Makefile b/pvDataApp/factory/Makefile
index 83359f7..b403318 100644
--- a/pvDataApp/factory/Makefile
+++ b/pvDataApp/factory/Makefile
@@ -16,7 +16,14 @@ INC += BasePVLong.h
 INC += BasePVFloat.h
 INC += BasePVDouble.h
 INC += BasePVString.h
+INC += BasePVBooleanArray.h
+INC += BasePVByteArray.h
+INC += BasePVShortArray.h
+INC += BasePVIntArray.h
+INC += BasePVLongArray.h
+INC += BasePVFloatArray.h
 INC += BasePVDoubleArray.h
+INC += BasePVString.h
 INC += BasePVStructure.h
 INC += BasePVStructureArray.h
 LIBSRCS += TypeFunc.cpp
diff --git a/pvDataApp/factory/PVDataCreateFactory.cpp b/pvDataApp/factory/PVDataCreateFactory.cpp
index cdac195..e7a095f 100644
--- a/pvDataApp/factory/PVDataCreateFactory.cpp
+++ b/pvDataApp/factory/PVDataCreateFactory.cpp
@@ -21,7 +21,14 @@
 #include "BasePVDouble.h"
 #include "BasePVString.h"
 #include "AbstractPVArray.h"
+#include "BasePVBooleanArray.h"
+#include "BasePVByteArray.h"
+#include "BasePVShortArray.h"
+#include "BasePVIntArray.h"
+#include "BasePVLongArray.h"
+#include "BasePVFloatArray.h"
 #include "BasePVDoubleArray.h"
+#include "BasePVStringArray.h"
 #include "BasePVStructure.h"
 #include "BasePVStructureArray.h"
 
@@ -121,15 +128,22 @@ namespace epics { namespace pvData {
            ScalarArrayConstPtr scalarArray)
    {
         switch(scalarArray->getElementType()) {
-        case pvBoolean: break;
-        case pvByte:    break;
-        case pvShort:   break;
-        case pvInt:     break;
-        case pvLong:    break;
-        case pvFloat:   break;
+        case pvBoolean:
+              return new BasePVBooleanArray(parent,scalarArray);
+        case pvByte:
+              return new BasePVByteArray(parent,scalarArray);
+        case pvShort:
+              return new BasePVShortArray(parent,scalarArray);
+        case pvInt:
+              return new BasePVIntArray(parent,scalarArray);
+        case pvLong:
+              return new BasePVLongArray(parent,scalarArray);
+        case pvFloat:
+              return new BasePVFloatArray(parent,scalarArray);
         case pvDouble:
               return new BasePVDoubleArray(parent,scalarArray);
-        case pvString:  break;
+        case pvString:
+              return new BasePVStringArray(parent,scalarArray);
         }
         throw std::logic_error(notImplemented);
         
@@ -178,8 +192,8 @@ namespace epics { namespace pvData {
    };
 
     PVDataCreate * getPVDataCreate() {
-        static Mutex *mutex = new Mutex();
-        Lock xx(mutex);
+        static Mutex mutex = Mutex();
+        Lock xx(&mutex);
 
         if(pvDataCreate==0) pvDataCreate = new PVDataCreateExt();
         return pvDataCreate;
diff --git a/pvDataApp/factory/StandardField.cpp b/pvDataApp/factory/StandardField.cpp
index 23a15cb..7d0d72d 100644
--- a/pvDataApp/factory/StandardField.cpp
+++ b/pvDataApp/factory/StandardField.cpp
@@ -71,8 +71,8 @@ static String notImplemented("not implemented");
     };
 
     StandardField * getStandardField() {
-        static Mutex *mutex = new Mutex();
-        Lock xx(mutex);
+        static Mutex mutex = Mutex();
+        Lock xx(&mutex);
 
         if(instance==0) instance = new StandardFieldExt();
         return instance;
diff --git a/pvDataApp/pv/pvData.h b/pvDataApp/pv/pvData.h
index d216283..1838afa 100644
--- a/pvDataApp/pv/pvData.h
+++ b/pvDataApp/pv/pvData.h
@@ -58,6 +58,7 @@ namespace epics { namespace pvData {
     };
 
     class PostHandler {
+    public:
         virtual void postPut() = 0;
     };
 
@@ -81,7 +82,7 @@ namespace epics { namespace pvData {
         void setPostHandler(PostHandler *postHandler);
         virtual void toString(StringBuilder buf) ;
         virtual void toString(StringBuilder buf,int indentLevel) ;
-        virtual epicsBoolean equals(PVField *pv)  = 0;
+        virtual epicsBoolean equals(PVField *pv) = 0;
     protected:
         PVField(PVStructure *parent,FieldConstPtr field);
         void replaceStructure();
@@ -95,8 +96,8 @@ namespace epics { namespace pvData {
     public:
         virtual ~PVScalar();
         ScalarConstPtr getScalar() ;
-        virtual void toString(StringBuilder buf)  = 0;
-        virtual void toString(StringBuilder buf,int indentLevel)  = 0;
+        virtual void toString(StringBuilder buf) = 0;
+        virtual void toString(StringBuilder buf,int indentLevel) = 0;
     protected:
         PVScalar(PVStructure *parent,ScalarConstPtr scalar);
     };
@@ -107,19 +108,20 @@ namespace epics { namespace pvData {
         int getLength() ;
         void setLength(int length);
         int getCapacity() ;
-        epicsBoolean isCapacityImmutable() ;
-        void setCapacityImmutable(epicsBoolean isMutable);
+        epicsBoolean isCapacityMutable() ;
+        void setCapacityMutable(epicsBoolean isMutable);
         virtual void setCapacity(int capacity) = 0;
         virtual void serialize(ByteBuffer *pbuffer,
-            SerializableControl *pflusher)  = 0;
+            SerializableControl *pflusher) = 0;
         virtual void deserialize(ByteBuffer *pbuffer,
             DeserializableControl *pflusher) = 0;
         virtual void serialize(ByteBuffer *pbuffer,
-            SerializableControl *pflusher, int offset, int count)  = 0;
-        virtual void toString(StringBuilder buf) ;
-        virtual void toString(StringBuilder buf,int indentLevel)  = 0;
+            SerializableControl *pflusher, int offset, int count) = 0;
+        virtual void toString(StringBuilder buf) = 0;
+        virtual void toString(StringBuilder buf,int indentLevel) = 0;
     protected:
         PVArray(PVStructure *parent,FieldConstPtr field);
+        void setCapacityLength(int capacity,int length);
     private:
         class PVArrayPvt * pImpl;
     };
@@ -131,13 +133,13 @@ namespace epics { namespace pvData {
         ScalarArrayConstPtr getScalarArray() ;
         virtual void setCapacity(int capacity) = 0;
         virtual void serialize(ByteBuffer *pbuffer,
-            SerializableControl *pflusher)  = 0;
+            SerializableControl *pflusher) = 0;
         virtual void deserialize(ByteBuffer *pbuffer,
             DeserializableControl *pflusher) = 0;
         virtual void serialize(ByteBuffer *pbuffer,
-            SerializableControl *pflusher, int offset, int count)  = 0;
-        virtual void toString(StringBuilder buf)  = 0;
-        virtual void toString(StringBuilder buf,int indentLevel)  = 0;
+            SerializableControl *pflusher, int offset, int count) = 0;
+        virtual void toString(StringBuilder buf) = 0;
+        virtual void toString(StringBuilder buf,int indentLevel) = 0;
     protected:
         PVScalarArray(PVStructure *parent,ScalarArrayConstPtr scalarArray);
     private:
@@ -154,21 +156,22 @@ namespace epics { namespace pvData {
     class PVStructureArray : public PVArray {
     public:
         virtual ~PVStructureArray();
-        virtual StructureArrayConstPtr getStructureArray() ;
+        virtual StructureArrayConstPtr getStructureArray() = 0;
         virtual int get(int offset, int length,
-            StructureArrayData *data) ;
+            StructureArrayData *data) = 0;
         virtual int put(int offset,int length,
-            PVStructurePtrArray from, int fromOffset);
-        virtual void shareData(StructureArrayData *from);
+            PVStructurePtrArray from, int fromOffset) = 0;
+        virtual void shareData(
+            PVStructurePtrArray value,int capacity,int length) = 0;
         virtual void serialize(ByteBuffer *pbuffer,
-            SerializableControl *pflusher) ;
+            SerializableControl *pflusher) = 0 ;
         virtual void deserialize(ByteBuffer *buffer,
-            DeserializableControl *pflusher);
+            DeserializableControl *pflusher) = 0;
         virtual void serialize(ByteBuffer *pbuffer,
-            SerializableControl *pflusher, int offset, int count) ;
-        virtual void toString(StringBuilder buf) ;
-        virtual void toString(StringBuilder buf,int indentLevel) ;
-        virtual epicsBoolean equals(PVField *pv) ;
+            SerializableControl *pflusher, int offset, int count) = 0;
+        virtual void toString(StringBuilder buf) = 0;
+        virtual void toString(StringBuilder buf,int indentLevel) = 0;
+        virtual epicsBoolean equals(PVField *pv) = 0;
     protected:
         PVStructureArray(PVStructure *parent,
             StructureArrayConstPtr structureArray);
@@ -226,7 +229,7 @@ namespace epics { namespace pvData {
     class PVBoolean : public PVScalar {
     public:
         virtual ~PVBoolean();
-        virtual epicsBoolean get()  = 0;
+        virtual epicsBoolean get() = 0;
         virtual void put(epicsBoolean value) = 0;
     protected:
         PVBoolean(PVStructure *parent,ScalarConstPtr scalar)
@@ -237,7 +240,7 @@ namespace epics { namespace pvData {
     class PVByte : public PVScalar {
     public:
         virtual ~PVByte();
-        virtual epicsInt8 get()  = 0;
+        virtual epicsInt8 get() = 0;
         virtual void put(epicsInt8 value) = 0;
     protected:
         PVByte(PVStructure *parent,ScalarConstPtr scalar)
@@ -248,7 +251,7 @@ namespace epics { namespace pvData {
     class PVShort : public PVScalar {
     public:
         virtual ~PVShort();
-        virtual epicsInt16 get()  = 0;
+        virtual epicsInt16 get() = 0;
         virtual void put(epicsInt16 value) = 0;
     protected:
         PVShort(PVStructure *parent,ScalarConstPtr scalar)
@@ -259,7 +262,7 @@ namespace epics { namespace pvData {
     class PVInt : public PVScalar{
     public:
         virtual ~PVInt();
-        virtual epicsInt32 get()  = 0;
+        virtual epicsInt32 get() = 0;
         virtual void put(epicsInt32 value) = 0;
     protected:
         PVInt(PVStructure *parent,ScalarConstPtr scalar)
@@ -270,7 +273,7 @@ namespace epics { namespace pvData {
     class PVLong : public PVScalar {
     public:
         virtual ~PVLong();
-        virtual epicsInt64 get()  = 0;
+        virtual epicsInt64 get() = 0;
         virtual void put(epicsInt64 value) = 0;
     protected:
         PVLong(PVStructure *parent,ScalarConstPtr scalar)
@@ -281,7 +284,7 @@ namespace epics { namespace pvData {
     class PVFloat : public PVScalar {
     public:
         virtual ~PVFloat();
-        virtual float get()  = 0;
+        virtual float get() = 0;
         virtual void put(float value) = 0;
     protected:
         PVFloat(PVStructure *parent,ScalarConstPtr scalar)
@@ -292,7 +295,7 @@ namespace epics { namespace pvData {
     class PVDouble : public PVScalar {
     public:
         virtual ~PVDouble();
-        virtual double get()  = 0;
+        virtual double get() = 0;
         virtual void put(double value) = 0;
     protected:
         PVDouble(PVStructure *parent,ScalarConstPtr scalar)
@@ -303,7 +306,7 @@ namespace epics { namespace pvData {
     class PVString : public PVScalar {
     public:
         virtual ~PVString();
-        virtual String get()  = 0;
+        virtual String get() = 0;
         virtual void put(String value) = 0;
     protected:
         PVString(PVStructure *parent,ScalarConstPtr scalar)
@@ -322,15 +325,15 @@ namespace epics { namespace pvData {
     class PVBooleanArray : public PVScalarArray {
     public:
         virtual ~PVBooleanArray();
-        virtual void toString(StringBuilder buf) ;
-        virtual void toString(StringBuilder buf,int indentLevel) ;
-        virtual int get(int offset, int length, BooleanArrayData *data) ;
-        virtual int put(int offset,int length, BooleanArray from, int fromOffset);
-        virtual void shareData(BooleanArrayData *from);
-        virtual void serialize(ByteBuffer *pbuffer,SerializableControl *pflusher) ;
-        virtual void deserialize(ByteBuffer *pbuffer,DeserializableControl *pflusher);
+        virtual void toString(StringBuilder buf) = 0 ;
+        virtual void toString(StringBuilder buf,int indentLevel) = 0 ;
+        virtual int get(int offset, int length, BooleanArrayData *data) = 0;
+        virtual int put(int offset,int length, BooleanArray from, int fromOffset) = 0;
+        virtual void shareData(epicsBoolean value[],int capacity,int length) = 0;
+        virtual void serialize(ByteBuffer *pbuffer,SerializableControl *pflusher) = 0;
+        virtual void deserialize(ByteBuffer *pbuffer,DeserializableControl *pflusher) = 0;
     protected:
-        PVBooleanArray(PVStructure *parent,ScalarConstPtr scalar);
+        PVBooleanArray(PVStructure *parent,ScalarArrayConstPtr scalar);
     private:
     };
 
@@ -345,15 +348,15 @@ namespace epics { namespace pvData {
     class PVByteArray : public PVScalarArray {
     public:
         virtual ~PVByteArray();
-        virtual void toString(StringBuilder buf) ;
-        virtual void toString(StringBuilder buf,int indentLevel) ;
-        virtual int get(int offset, int length, ByteArrayData *data) ;
-        virtual int put(int offset,int length, ByteArray  from, int fromOffset);
-        virtual void shareData(ByteArrayData *from);
-        virtual void serialize(ByteBuffer *pbuffer,SerializableControl *pflusher) ;
-        virtual void deserialize(ByteBuffer *pbuffer,DeserializableControl *pflusher);
+        virtual void toString(StringBuilder buf) = 0 ;
+        virtual void toString(StringBuilder buf,int indentLevel) = 0;
+        virtual int get(int offset, int length, ByteArrayData *data) = 0;
+        virtual int put(int offset,int length, ByteArray  from, int fromOffset) = 0;
+        virtual void shareData(epicsInt8 value[],int capacity,int length) = 0;
+        virtual void serialize(ByteBuffer *pbuffer,SerializableControl *pflusher) = 0;
+        virtual void deserialize(ByteBuffer *pbuffer,DeserializableControl *pflusher) = 0;
     protected:
-        PVByteArray(PVStructure *parent,ScalarConstPtr scalar);
+        PVByteArray(PVStructure *parent,ScalarArrayConstPtr scalar);
     private:
     };
 
@@ -368,15 +371,15 @@ namespace epics { namespace pvData {
     class PVShortArray : public PVScalarArray {
     public:
         virtual ~PVShortArray();
-        virtual void toString(StringBuilder buf) ;
-        virtual void toString(StringBuilder buf,int indentLevel) ;
-        virtual int get(int offset, int length, ShortArrayData *data) ;
-        virtual int put(int offset,int length, ShortArray  from, int fromOffset);
-        virtual void shareData(ShortArrayData *from);
-        virtual void serialize(ByteBuffer *pbuffer,SerializableControl *pflusher) ;
-        virtual void deserialize(ByteBuffer *pbuffer,DeserializableControl *pflusher);
+        virtual void toString(StringBuilder buf) = 0;
+        virtual void toString(StringBuilder buf,int indentLevel) = 0;
+        virtual int get(int offset, int length, ShortArrayData *data) = 0;
+        virtual int put(int offset,int length, ShortArray  from, int fromOffset) = 0;
+        virtual void shareData(epicsInt16 value[],int capacity,int length) = 0;
+        virtual void serialize(ByteBuffer *pbuffer,SerializableControl *pflusher) = 0;
+        virtual void deserialize(ByteBuffer *pbuffer,DeserializableControl *pflusher) = 0;
     protected:
-        PVShortArray(PVStructure *parent,ScalarConstPtr scalar);
+        PVShortArray(PVStructure *parent,ScalarArrayConstPtr scalar);
     private:
     };
 
@@ -390,15 +393,15 @@ namespace epics { namespace pvData {
     class PVIntArray : public PVScalarArray {
     public:
         virtual ~PVIntArray();
-        virtual void toString(StringBuilder buf) ;
-        virtual void toString(StringBuilder buf,int indentLevel) ;
-        virtual int get(int offset, int length, IntArrayData *data) ;
-        virtual int put(int offset,int length, IntArray  from, int fromOffset);
-        virtual void shareData(IntArrayData *from);
-        virtual void serialize(ByteBuffer *pbuffer,SerializableControl *pflusher) ;
-        virtual void deserialize(ByteBuffer *pbuffer,DeserializableControl *pflusher);
+        virtual void toString(StringBuilder buf) = 0;
+        virtual void toString(StringBuilder buf,int indentLevel) = 0;
+        virtual int get(int offset, int length, IntArrayData *data) = 0;
+        virtual int put(int offset,int length, IntArray  from, int fromOffset)= 0;
+        virtual void shareData(epicsInt32 value[],int capacity,int length)= 0;
+        virtual void serialize(ByteBuffer *pbuffer,SerializableControl *pflusher) = 0;
+        virtual void deserialize(ByteBuffer *pbuffer,DeserializableControl *pflusher)= 0;
     protected:
-        PVIntArray(PVStructure *parent,ScalarConstPtr scalar);
+        PVIntArray(PVStructure *parent,ScalarArrayConstPtr scalar);
     private:
     };
 
@@ -413,15 +416,15 @@ namespace epics { namespace pvData {
     class PVLongArray : public PVScalarArray {
     public:
         virtual ~PVLongArray();
-        virtual void toString(StringBuilder buf) ;
-        virtual void toString(StringBuilder buf,int indentLevel) ;
-        virtual int get(int offset, int length, LongArrayData *data) ;
-        virtual int put(int offset,int length, LongArray  from, int fromOffset);
-        virtual void shareData(LongArrayData *from);
-        virtual void serialize(ByteBuffer *pbuffer,SerializableControl *pflusher) ;
-        virtual void deserialize(ByteBuffer *pbuffer,DeserializableControl *pflusher);
+        virtual void toString(StringBuilder buf) = 0;
+        virtual void toString(StringBuilder buf,int indentLevel) = 0;
+        virtual int get(int offset, int length, LongArrayData *data) = 0;
+        virtual int put(int offset,int length, LongArray  from, int fromOffset)= 0;
+        virtual void shareData(epicsInt64 value[],int capacity,int length)= 0;
+        virtual void serialize(ByteBuffer *pbuffer,SerializableControl *pflusher) = 0;
+        virtual void deserialize(ByteBuffer *pbuffer,DeserializableControl *pflusher)= 0;
     protected:
-        PVLongArray(PVStructure *parent,ScalarConstPtr scalar);
+        PVLongArray(PVStructure *parent,ScalarArrayConstPtr scalar);
     private:
     };
 
@@ -436,15 +439,15 @@ namespace epics { namespace pvData {
     class PVFloatArray : public PVScalarArray {
     public:
         virtual ~PVFloatArray();
-        virtual void toString(StringBuilder buf) ;
-        virtual void toString(StringBuilder buf,int indentLevel) ;
-        virtual int get(int offset, int length, FloatArrayData *data) ;
-        virtual int put(int offset,int length, FloatArray  from, int fromOffset);
-        virtual void shareData(FloatArrayData *from);
-        virtual void serialize(ByteBuffer *pbuffer,SerializableControl *pflusher) ;
-        virtual void deserialize(ByteBuffer *pbuffer,DeserializableControl *pflusher);
+        virtual void toString(StringBuilder buf) = 0;
+        virtual void toString(StringBuilder buf,int indentLevel) = 0;
+        virtual int get(int offset, int length, FloatArrayData *data) = 0;
+        virtual int put(int offset,int length, FloatArray  from, int fromOffset)= 0;
+        virtual void shareData(float value[],int capacity,int length)= 0;
+        virtual void serialize(ByteBuffer *pbuffer,SerializableControl *pflusher) = 0;
+        virtual void deserialize(ByteBuffer *pbuffer,DeserializableControl *pflusher)= 0;
     protected:
-        PVFloatArray(PVStructure *parent,ScalarConstPtr scalar);
+        PVFloatArray(PVStructure *parent,ScalarArrayConstPtr scalar);
     private:
     };
 
@@ -452,6 +455,8 @@ namespace epics { namespace pvData {
     typedef double * DoubleArray;
     class DoubleArrayData {
     public:
+        DoubleArrayData(){}
+        ~DoubleArrayData(){};
         DoubleArray data;
         int offset;
     };
@@ -459,12 +464,12 @@ namespace epics { namespace pvData {
     class PVDoubleArray : public PVScalarArray {
     public:
         virtual ~PVDoubleArray();
-        virtual void toString(StringBuilder buf)  = 0;
-        virtual void toString(StringBuilder buf,int indentLevel)  = 0;
-        virtual int get(int offset, int length, DoubleArrayData *data)  = 0;
+        virtual void toString(StringBuilder buf) = 0;
+        virtual void toString(StringBuilder buf,int indentLevel) = 0;
+        virtual int get(int offset, int length, DoubleArrayData *data) = 0;
         virtual int put(int offset,int length, DoubleArray  from, int fromOffset) = 0;
-        virtual void shareData(DoubleArrayData *from) = 0;
-        virtual void serialize(ByteBuffer *pbuffer,SerializableControl *pflusher)  = 0;
+        virtual void shareData(double value[],int capacity,int length) = 0;
+        virtual void serialize(ByteBuffer *pbuffer,SerializableControl *pflusher) = 0;
         virtual void deserialize(ByteBuffer *pbuffer,DeserializableControl *pflusher) = 0;
     protected:
         PVDoubleArray(PVStructure *parent,ScalarArrayConstPtr scalar);
@@ -482,15 +487,15 @@ namespace epics { namespace pvData {
     class PVStringArray : public PVScalarArray {
     public:
         virtual ~PVStringArray();
-        virtual void toString(StringBuilder buf) ;
-        virtual void toString(StringBuilder buf,int indentLevel) ;
-        virtual int get(int offset, int length, StringArrayData *data) ;
-        virtual int put(int offset,int length, StringArray  from, int fromOffset);
-        virtual void shareData(StringArrayData from);
-        virtual void serialize(ByteBuffer *pbuffer,SerializableControl *pflusher) ;
-        virtual void deserialize(ByteBuffer *pbuffer,DeserializableControl *pflusher);
+        virtual void toString(StringBuilder buf) = 0;
+        virtual void toString(StringBuilder buf,int indentLevel) = 0;
+        virtual int get(int offset, int length, StringArrayData *data) = 0;
+        virtual int put(int offset,int length, StringArray  from, int fromOffset)= 0;
+        virtual void shareData(String value[],int capacity,int length)= 0;
+        virtual void serialize(ByteBuffer *pbuffer,SerializableControl *pflusher) = 0;
+        virtual void deserialize(ByteBuffer *pbuffer,DeserializableControl *pflusher)= 0;
     protected:
-        PVStringArray(PVStructure *parent,ScalarConstPtr scalar);
+        PVStringArray(PVStructure *parent,ScalarArrayConstPtr scalar);
     private:
     };
 
diff --git a/pvDataApp/test/Makefile b/pvDataApp/test/Makefile
index fbb52d1..dfc1863 100644
--- a/pvDataApp/test/Makefile
+++ b/pvDataApp/test/Makefile
@@ -14,6 +14,14 @@ PROD_HOST += testPVScalar
 testPVScalar_SRCS += testPVScalar.cpp
 testPVScalar_LIBS += pvFactory
 
+PROD_HOST += testPVScalarArray
+testPVScalarArray_SRCS += testPVScalarArray.cpp
+testPVScalarArray_LIBS += pvFactory
+
+PROD_HOST += testSimpleStructure
+testSimpleStructure_SRCS += testSimpleStructure.cpp
+testSimpleStructure_LIBS += pvFactory
+
 include $(TOP)/configure/RULES
 #----------------------------------------
 #  ADD RULES AFTER THIS LINE
diff --git a/pvDataApp/test/testIntrospect.cpp b/pvDataApp/test/testIntrospect.cpp
index d0e0cce..b2f9477 100644
--- a/pvDataApp/test/testIntrospect.cpp
+++ b/pvDataApp/test/testIntrospect.cpp
@@ -1,5 +1,5 @@
-/* pvDataMain.cpp */
-/* Author:  Marty Kraimer Date:    17MAR2000 */
+/* testIntrospect.cpp */
+/* Author:  Marty Kraimer Date: 2010.09 */
 
 #include <stddef.h>
 #include <stdlib.h>
diff --git a/pvDataApp/test/testPVScalar.cpp b/pvDataApp/test/testPVScalar.cpp
index 03619d3..15fcb75 100644
--- a/pvDataApp/test/testPVScalar.cpp
+++ b/pvDataApp/test/testPVScalar.cpp
@@ -1,5 +1,5 @@
-/* pvDataMain.cpp */
-/* Author:  Marty Kraimer Date:    17MAR2000 */
+/* testPVscalar.cpp */
+/* Author:  Marty Kraimer Date: 2010.09 */
 
 #include <stddef.h>
 #include <stdlib.h>
diff --git a/pvDataApp/test/testPVScalarArray.cpp b/pvDataApp/test/testPVScalarArray.cpp
new file mode 100644
index 0000000..0c5df63
--- /dev/null
+++ b/pvDataApp/test/testPVScalarArray.cpp
@@ -0,0 +1,271 @@
+/* testPVArray.cpp */
+/* Author:  Marty Kraimer Date: 2010.09 */
+
+#include <stddef.h>
+#include <stdlib.h>
+#include <stddef.h>
+#include <string.h>
+#include <stdio.h>
+
+#include "requester.h"
+#include "pvIntrospect.h"
+#include "pvData.h"
+#include "standardField.h"
+
+using namespace epics::pvData;
+
+static FieldCreate * pfieldCreate = 0;
+static PVDataCreate *pvDataCreate = 0;
+static String buffer("");
+
+void testBooleanArray() {
+    printf("\ntestBooleanArray\n");
+    PVScalarArray *pvScalarArray =
+        getStandardField()->scalarArrayValue(pvBoolean);
+    PVBooleanArray *pvValue = (PVBooleanArray *)pvScalarArray;
+    int length = 5;
+    epicsBoolean *value = new epicsBoolean[length];
+    for(int i=0; i<length; i++) value[i] = epicsTrue;
+    pvValue->put(0,length,value,0);
+    BooleanArrayData data = BooleanArrayData();
+    pvValue->get(0,length,&data);
+    epicsBoolean * getValue = data.data;
+    printf("(orig,get):");
+    for(int i=0; i< length; i++) {
+        printf("(%s,%s) ",
+            ((value[i]==epicsTrue) ? "true" : "false"),
+            ((getValue[i]==epicsTrue) ? "true" : "false"));
+    }
+    printf("\n");
+    FieldConstPtr field = pvValue->getField();
+    buffer.clear();
+    field->toString(&buffer);
+    printf("%s\n",buffer.c_str());
+    buffer.clear();
+    buffer += "pv ";
+    pvValue->toString(&buffer);
+    printf("%s\n",buffer.c_str());
+    delete pvValue;
+    delete[] value;
+}
+void testByteArray() {
+    printf("\ntestByteArray\n");
+    PVScalarArray *pvScalarArray =
+        getStandardField()->scalarArrayValue(pvByte);
+    PVByteArray *pvValue = (PVByteArray *)pvScalarArray;
+    int length = 5;
+    epicsInt8 *value = new epicsInt8[length];
+    for(int i=0; i<length; i++) value[i] = i;
+    pvValue->put(0,length,value,0);
+    ByteArrayData data = ByteArrayData();
+    pvValue->get(0,length,&data);
+    epicsInt8 * getValue = data.data;
+    printf("(orig,get):");
+    for(int i=0; i< length; i++) {
+        printf("(%d,%d) ",(int)value[i],(int)getValue[i]);
+    }
+    printf("\n");
+    FieldConstPtr field = pvValue->getField();
+    buffer.clear();
+    field->toString(&buffer);
+    printf("%s\n",buffer.c_str());
+    buffer.clear();
+    buffer += "pv ";
+    pvValue->toString(&buffer);
+    printf("%s\n",buffer.c_str());
+    delete pvValue;
+    delete[] value;
+}
+void testShortArray() {
+    printf("\ntestShortArray\n");
+    PVScalarArray *pvScalarArray =
+        getStandardField()->scalarArrayValue(pvShort);
+    PVShortArray *pvValue = (PVShortArray *)pvScalarArray;
+    int length = 5;
+    epicsInt16 *value = new epicsInt16[length];
+    for(int i=0; i<length; i++) value[i] = i;
+    pvValue->put(0,length,value,0);
+    ShortArrayData data = ShortArrayData();
+    pvValue->get(0,length,&data);
+    epicsInt16 * getValue = data.data;
+    printf("(orig,get):");
+    for(int i=0; i< length; i++) {
+        printf("(%d,%d) ",(int)value[i],(int)getValue[i]);
+    }
+    printf("\n");
+    FieldConstPtr field = pvValue->getField();
+    buffer.clear();
+    field->toString(&buffer);
+    printf("%s\n",buffer.c_str());
+    buffer.clear();
+    buffer += "pv ";
+    pvValue->toString(&buffer);
+    printf("%s\n",buffer.c_str());
+    delete pvValue;
+    delete[] value;
+}
+void testIntArray() {
+    printf("\ntestIntArray\n");
+    PVScalarArray *pvScalarArray =
+        getStandardField()->scalarArrayValue(pvInt);
+    PVIntArray *pvValue = (PVIntArray *)pvScalarArray;
+    int length = 5;
+    epicsInt32 *value = new epicsInt32[length];
+    for(int i=0; i<length; i++) value[i] = i;
+    pvValue->put(0,length,value,0);
+    IntArrayData data = IntArrayData();
+    pvValue->get(0,length,&data);
+    epicsInt32 * getValue = data.data;
+    printf("(orig,get):");
+    for(int i=0; i< length; i++) {
+        printf("(%d,%d) ",value[i],getValue[i]);
+    }
+    printf("\n");
+    FieldConstPtr field = pvValue->getField();
+    buffer.clear();
+    field->toString(&buffer);
+    printf("%s\n",buffer.c_str());
+    buffer.clear();
+    buffer += "pv ";
+    pvValue->toString(&buffer);
+    printf("%s\n",buffer.c_str());
+    delete pvValue;
+    delete[] value;
+}
+
+void testLongArray() {
+    printf("\ntestLongArray\n");
+    PVScalarArray *pvScalarArray =
+        getStandardField()->scalarArrayValue(pvLong);
+    PVLongArray *pvValue = (PVLongArray *)pvScalarArray;
+    int length = 5;
+    epicsInt64 *value = new epicsInt64[length];
+    for(int i=0; i<length; i++) value[i] = i;
+    pvValue->put(0,length,value,0);
+    LongArrayData data = LongArrayData();
+    pvValue->get(0,length,&data);
+    epicsInt64 * getValue = data.data;
+    printf("(orig,get):");
+    for(int i=0; i< length; i++) {
+        printf("(%ld,%ld) ",(long int)value[i],(long int)getValue[i]);
+    }
+    printf("\n");
+    FieldConstPtr field = pvValue->getField();
+    buffer.clear();
+    field->toString(&buffer);
+    printf("%s\n",buffer.c_str());
+    buffer.clear();
+    buffer += "pv ";
+    pvValue->toString(&buffer);
+    printf("%s\n",buffer.c_str());
+    delete pvValue;
+    delete[] value;
+}
+
+void testFloatArray() {
+    printf("\ntestFloatArray\n");
+    PVScalarArray *pvScalarArray =
+        getStandardField()->scalarArrayValue(pvFloat);
+    PVFloatArray *pvValue = (PVFloatArray *)pvScalarArray;
+    int length = 5;
+    float *value = new float[length];
+    for(int i=0; i<length; i++) value[i] = i;
+    pvValue->put(0,length,value,0);
+    FloatArrayData data = FloatArrayData();
+    pvValue->get(0,length,&data);
+    float * getValue = data.data;
+    printf("(orig,get):");
+    for(int i=0; i< length; i++) {
+        printf("(%f,%f) ",value[i],getValue[i]);
+    }
+    printf("\n");
+    FieldConstPtr field = pvValue->getField();
+    buffer.clear();
+    field->toString(&buffer);
+    printf("%s\n",buffer.c_str());
+    buffer.clear();
+    buffer += "pv ";
+    pvValue->toString(&buffer);
+    printf("%s\n",buffer.c_str());
+    delete pvValue;
+    delete[] value;
+}
+
+void testDoubleArray() {
+    printf("\ntestDoubleArray\n");
+    PVScalarArray *pvScalarArray =
+        getStandardField()->scalarArrayValue(pvDouble);
+    PVDoubleArray *pvValue = (PVDoubleArray *)pvScalarArray;
+    int length = 5;
+    double *value = new double[length];
+    for(int i=0; i<length; i++) value[i] = i;
+    pvValue->put(0,length,value,0);
+    DoubleArrayData data = DoubleArrayData();
+    pvValue->get(0,length,&data);
+    double * getValue = data.data;
+    printf("(orig,get):");
+    for(int i=0; i< length; i++) {
+        printf("(%f,%f) ",value[i],getValue[i]);
+    }
+    printf("\n");
+    FieldConstPtr field = pvValue->getField();
+    buffer.clear();
+    field->toString(&buffer);
+    printf("%s\n",buffer.c_str());
+    buffer.clear();
+    buffer += "pv ";
+    pvValue->toString(&buffer);
+    printf("%s\n",buffer.c_str());
+    delete pvValue;
+    delete[] value;
+}
+
+void testStringArray() {
+    printf("\ntestStringArray\n");
+    PVScalarArray *pvScalarArray =
+        getStandardField()->scalarArrayValue(pvString);
+    PVStringArray *pvValue = (PVStringArray *)pvScalarArray;
+    int length = 5;
+    String *value = new String[length];
+    for(int i=0; i<length; i++) {
+        char buf[16];
+        sprintf(buf,"string%d",i);
+        value[i] = buf;
+    }
+    pvValue->put(0,length,value,0);
+    StringArrayData data = StringArrayData();
+    pvValue->get(0,length,&data);
+    String * getValue = data.data;
+    printf("(orig,get):");
+    for(int i=0; i< length; i++) {
+        printf("(%s,%s) ",value[i].c_str(),getValue[i].c_str());
+    }
+    printf("\n");
+    FieldConstPtr field = pvValue->getField();
+    buffer.clear();
+    field->toString(&buffer);
+    printf("%s\n",buffer.c_str());
+    buffer.clear();
+    buffer += "pv ";
+    pvValue->toString(&buffer);
+    printf("%s\n",buffer.c_str());
+    delete pvValue;
+    delete[] value;
+}
+
+int main(int argc,char *argv[])
+{
+    pfieldCreate = getFieldCreate();
+    pvDataCreate = getPVDataCreate();
+    testBooleanArray();
+    testByteArray();
+    testShortArray();
+    testIntArray();
+    testLongArray();
+    testFloatArray();
+    testDoubleArray();
+    testStringArray();
+    printf("main returning\n");
+    return(0);
+}
+
diff --git a/pvDataApp/test/testSimpleStructure.cpp b/pvDataApp/test/testSimpleStructure.cpp
new file mode 100644
index 0000000..4b731d7
--- /dev/null
+++ b/pvDataApp/test/testSimpleStructure.cpp
@@ -0,0 +1,75 @@
+/* testSimpleStructure.cpp */
+/* Author:  Marty Kraimer Date: 2010.09 */
+
+#include <stddef.h>
+#include <stdlib.h>
+#include <stddef.h>
+#include <string.h>
+#include <stdio.h>
+
+#include "requester.h"
+#include "pvIntrospect.h"
+#include "pvData.h"
+#include "standardField.h"
+
+using namespace epics::pvData;
+
+static FieldCreate * pfieldCreate = 0;
+static PVDataCreate *pvDataCreate = 0;
+static String buffer("");
+
+
+void testSimpleStructure() {
+    printf("\ntestSimpleStructure\n");
+    String secondsPastEpoch("secondsPastEpoch");
+    String nanoSeconds("nanoSeconds");
+    String timeStamp("timeStamp");
+    String severity("severity");
+    String message("message");
+    String alarm("alarm");
+    String value("value");
+    String top("top");
+
+    ScalarConstPtr pseconds = pfieldCreate->createScalar(
+        secondsPastEpoch,pvLong);
+    ScalarConstPtr pnano = pfieldCreate->createScalar(
+        nanoSeconds,pvInt);
+    FieldConstPtrArray fields = new FieldConstPtr[2];
+    fields[0] = pseconds;
+    fields[1] = pnano;
+    StructureConstPtr ptimeStamp = pfieldCreate->createStructure(
+        timeStamp,2,fields);
+    ScalarConstPtr pseverity = pfieldCreate->createScalar(
+        severity,pvInt);
+    ScalarConstPtr pmessage = pfieldCreate->createScalar(
+        message,pvString);
+    fields = new FieldConstPtr[2];
+    fields[0] = pseverity;
+    fields[1] = pmessage;
+    StructureConstPtr palarm = pfieldCreate->createStructure(
+        alarm,2,fields);
+    ScalarConstPtr pvalue = pfieldCreate->createScalar(
+        value,pvDouble);
+    fields = new FieldConstPtr[3];
+    fields[0] = ptimeStamp;
+    fields[1] = palarm;
+    fields[2] = pvalue;
+    StructureConstPtr ptop = pfieldCreate->createStructure(
+        top,3,fields);
+buffer.clear();
+ptop->toString(&buffer);
+printf("%s\n",buffer.c_str());
+    PVStructure *pvStructure = pvDataCreate->createPVStructure( 0, ptop);
+    buffer.clear();
+    pvStructure->toString(&buffer);
+    printf("%s\n",buffer.c_str());
+}
+
+int main(int argc,char *argv[])
+{
+    pfieldCreate = getFieldCreate();
+    pvDataCreate = getPVDataCreate();
+    testSimpleStructure();
+    return(0);
+}
+