diff --git a/pvDataApp/factory/BasePVBoolean.h b/pvDataApp/factory/BasePVBoolean.h
index f0fd590..d151160 100644
--- a/pvDataApp/factory/BasePVBoolean.h
+++ b/pvDataApp/factory/BasePVBoolean.h
@@ -27,6 +27,7 @@ namespace epics { namespace pvData {
         virtual void toString(StringBuilder buf);
         virtual void toString(StringBuilder buf,int indentLevel);
         virtual bool operator==(PVField  *pv) ;
+        virtual bool operator!=(PVField  *pv) ;
     private:
         bool value;
     };
@@ -66,5 +67,10 @@ namespace epics { namespace pvData {
         return getConvert()->equals(this,pvField);
     }
 
+    bool BasePVBoolean::operator!=(PVField  *pvField) 
+    {
+        return !(getConvert()->equals(this,pvField));
+    }
+
 }}
 #endif  /* BASEPVBOOLEAN_H */
diff --git a/pvDataApp/factory/BasePVBooleanArray.h b/pvDataApp/factory/BasePVBooleanArray.h
index 5f7a5a6..e7524e7 100644
--- a/pvDataApp/factory/BasePVBooleanArray.h
+++ b/pvDataApp/factory/BasePVBooleanArray.h
@@ -34,6 +34,7 @@ namespace epics { namespace pvData {
         virtual void toString(StringBuilder buf);
         virtual void toString(StringBuilder buf,int indentLevel);
         virtual bool operator==(PVField  *pv) ;
+        virtual bool operator!=(PVField  *pv) ;
     private:
         bool *value;
     };
@@ -149,5 +150,10 @@ namespace epics { namespace pvData {
     {
         return getConvert()->equals(this,pv);
     }
+
+    bool BasePVBooleanArray::operator!=(PVField  *pv) 
+    {
+        return !(getConvert()->equals(this,pv));
+    }
 }}
 #endif  /* BASEPVBOOLEANARRAY_H */
diff --git a/pvDataApp/factory/BasePVByte.h b/pvDataApp/factory/BasePVByte.h
index 0f37456..dd3bf7c 100644
--- a/pvDataApp/factory/BasePVByte.h
+++ b/pvDataApp/factory/BasePVByte.h
@@ -27,6 +27,7 @@ namespace epics { namespace pvData {
         virtual void toString(StringBuilder buf);
         virtual void toString(StringBuilder buf,int indentLevel);
         virtual bool operator==(PVField  *pv) ;
+        virtual bool operator!=(PVField  *pv) ;
     private:
         epicsInt8 value;
     };
@@ -66,5 +67,10 @@ namespace epics { namespace pvData {
         return getConvert()->equals(this,pvField);
     }
 
+    bool BasePVByte::operator!=(PVField  *pvField) 
+    {
+        return !(getConvert()->equals(this,pvField));
+    }
+
 }}
 #endif  /* BASEPVBYTE_H */
diff --git a/pvDataApp/factory/BasePVByteArray.h b/pvDataApp/factory/BasePVByteArray.h
index e1939af..b95dcf4 100644
--- a/pvDataApp/factory/BasePVByteArray.h
+++ b/pvDataApp/factory/BasePVByteArray.h
@@ -34,6 +34,7 @@ namespace epics { namespace pvData {
         virtual void toString(StringBuilder buf);
         virtual void toString(StringBuilder buf,int indentLevel);
         virtual bool operator==(PVField  *pv) ;
+        virtual bool operator!=(PVField  *pv) ;
     private:
         epicsInt8 *value;
     };
@@ -149,5 +150,10 @@ namespace epics { namespace pvData {
     {
         return getConvert()->equals(this,pv);
     }
+
+    bool BasePVByteArray::operator!=(PVField  *pv) 
+    {
+        return !(getConvert()->equals(this,pv));
+    }
 }}
 #endif  /* BASEPVBYTEARRAY_H */
diff --git a/pvDataApp/factory/BasePVDouble.h b/pvDataApp/factory/BasePVDouble.h
index f8499b5..dd9988b 100644
--- a/pvDataApp/factory/BasePVDouble.h
+++ b/pvDataApp/factory/BasePVDouble.h
@@ -27,6 +27,7 @@ namespace epics { namespace pvData {
         virtual void toString(StringBuilder buf);
         virtual void toString(StringBuilder buf,int indentLevel);
         virtual bool operator==(PVField  *pv) ;
+        virtual bool operator!=(PVField  *pv) ;
     private:
         double value;
     };
@@ -66,5 +67,10 @@ namespace epics { namespace pvData {
         return getConvert()->equals(this,pvField);
     }
 
+    bool BasePVDouble::operator!=(PVField  *pvField) 
+    {
+        return !(getConvert()->equals(this,pvField));
+    }
+
 }}
 #endif  /* BASEPVDOUBLE_H */
diff --git a/pvDataApp/factory/BasePVDoubleArray.h b/pvDataApp/factory/BasePVDoubleArray.h
index a1ed474..adff154 100644
--- a/pvDataApp/factory/BasePVDoubleArray.h
+++ b/pvDataApp/factory/BasePVDoubleArray.h
@@ -34,6 +34,7 @@ namespace epics { namespace pvData {
         virtual void toString(StringBuilder buf);
         virtual void toString(StringBuilder buf,int indentLevel);
         virtual bool operator==(PVField  *pv) ;
+        virtual bool operator!=(PVField  *pv) ;
     private:
         double *value;
     };
@@ -149,5 +150,10 @@ namespace epics { namespace pvData {
     {
         return getConvert()->equals(this,pv);
     }
+
+    bool BasePVDoubleArray::operator!=(PVField  *pv) 
+    {
+        return !(getConvert()->equals(this,pv));
+    }
 }}
 #endif  /* BASEPVDOUBLEARRAY_H */
diff --git a/pvDataApp/factory/BasePVFloat.h b/pvDataApp/factory/BasePVFloat.h
index 3d56963..961b04c 100644
--- a/pvDataApp/factory/BasePVFloat.h
+++ b/pvDataApp/factory/BasePVFloat.h
@@ -27,6 +27,7 @@ namespace epics { namespace pvData {
         virtual void toString(StringBuilder buf);
         virtual void toString(StringBuilder buf,int indentLevel);
         virtual bool operator==(PVField  *pv) ;
+        virtual bool operator!=(PVField  *pv) ;
     private:
         float value;
     };
@@ -66,5 +67,10 @@ namespace epics { namespace pvData {
         return getConvert()->equals(this,pvField);
     }
 
+    bool BasePVFloat::operator!=(PVField  *pvField) 
+    {
+        return !(getConvert()->equals(this,pvField));
+    }
+
 }}
 #endif  /* BASEPVFLOAT_H */
diff --git a/pvDataApp/factory/BasePVFloatArray.h b/pvDataApp/factory/BasePVFloatArray.h
index 438d77b..0e38a5f 100644
--- a/pvDataApp/factory/BasePVFloatArray.h
+++ b/pvDataApp/factory/BasePVFloatArray.h
@@ -34,6 +34,7 @@ namespace epics { namespace pvData {
         virtual void toString(StringBuilder buf);
         virtual void toString(StringBuilder buf,int indentLevel);
         virtual bool operator==(PVField  *pv) ;
+        virtual bool operator!=(PVField  *pv) ;
     private:
         float *value;
     };
@@ -149,5 +150,10 @@ namespace epics { namespace pvData {
     {
         return getConvert()->equals(this,pv);
     }
+
+    bool BasePVFloatArray::operator!=(PVField  *pv) 
+    {
+        return !(getConvert()->equals(this,pv));
+    }
 }}
 #endif  /* BASEPVFLOATARRAY_H */
diff --git a/pvDataApp/factory/BasePVInt.h b/pvDataApp/factory/BasePVInt.h
index 526e2d6..a68465e 100644
--- a/pvDataApp/factory/BasePVInt.h
+++ b/pvDataApp/factory/BasePVInt.h
@@ -27,6 +27,7 @@ namespace epics { namespace pvData {
         virtual void toString(StringBuilder buf);
         virtual void toString(StringBuilder buf,int indentLevel);
         virtual bool operator==(PVField  *pv) ;
+        virtual bool operator!=(PVField  *pv) ;
     private:
         epicsInt32 value;
     };
@@ -66,5 +67,10 @@ namespace epics { namespace pvData {
         return getConvert()->equals(this,pvField);
     }
 
+    bool BasePVInt::operator!=(PVField  *pvField) 
+    {
+        return !(getConvert()->equals(this,pvField));
+    }
+
 }}
 #endif  /* BASEPVINT_H */
diff --git a/pvDataApp/factory/BasePVIntArray.h b/pvDataApp/factory/BasePVIntArray.h
index 4a066d0..aa97aa2 100644
--- a/pvDataApp/factory/BasePVIntArray.h
+++ b/pvDataApp/factory/BasePVIntArray.h
@@ -34,6 +34,7 @@ namespace epics { namespace pvData {
         virtual void toString(StringBuilder buf);
         virtual void toString(StringBuilder buf,int indentLevel);
         virtual bool operator==(PVField  *pv) ;
+        virtual bool operator!=(PVField  *pv) ;
     private:
         epicsInt32 *value;
     };
@@ -149,5 +150,10 @@ namespace epics { namespace pvData {
     {
         return getConvert()->equals(this,pv);
     }
+
+    bool BasePVIntArray::operator!=(PVField  *pv) 
+    {
+        return !(getConvert()->equals(this,pv));
+    }
 }}
 #endif  /* BASEPVINTARRAY_H */
diff --git a/pvDataApp/factory/BasePVLong.h b/pvDataApp/factory/BasePVLong.h
index bf3fa7b..860a7b9 100644
--- a/pvDataApp/factory/BasePVLong.h
+++ b/pvDataApp/factory/BasePVLong.h
@@ -27,6 +27,7 @@ namespace epics { namespace pvData {
         virtual void toString(StringBuilder buf);
         virtual void toString(StringBuilder buf,int indentLevel);
         virtual bool operator==(PVField  *pv) ;
+        virtual bool operator!=(PVField  *pv) ;
     private:
         epicsInt64 value;
     };
@@ -66,5 +67,10 @@ namespace epics { namespace pvData {
         return getConvert()->equals(this,pvField);
     }
 
+    bool BasePVLong::operator!=(PVField  *pvField) 
+    {
+        return !(getConvert()->equals(this,pvField));
+    }
+
 }}
 #endif  /* BASEPVLONG_H */
diff --git a/pvDataApp/factory/BasePVLongArray.h b/pvDataApp/factory/BasePVLongArray.h
index d4021f6..bafa09e 100644
--- a/pvDataApp/factory/BasePVLongArray.h
+++ b/pvDataApp/factory/BasePVLongArray.h
@@ -34,6 +34,7 @@ namespace epics { namespace pvData {
         virtual void toString(StringBuilder buf);
         virtual void toString(StringBuilder buf,int indentLevel);
         virtual bool operator==(PVField  *pv) ;
+        virtual bool operator!=(PVField  *pv) ;
     private:
         epicsInt64 *value;
     };
@@ -149,5 +150,10 @@ namespace epics { namespace pvData {
     {
         return getConvert()->equals(this,pv);
     }
+
+    bool BasePVLongArray::operator!=(PVField  *pv) 
+    {
+        return !(getConvert()->equals(this,pv));
+    }
 }}
 #endif  /* BASEPVLONGARRAY_H */
diff --git a/pvDataApp/factory/BasePVShort.h b/pvDataApp/factory/BasePVShort.h
index 4aecbe4..cd48e7c 100644
--- a/pvDataApp/factory/BasePVShort.h
+++ b/pvDataApp/factory/BasePVShort.h
@@ -27,6 +27,7 @@ namespace epics { namespace pvData {
         virtual void toString(StringBuilder buf);
         virtual void toString(StringBuilder buf,int indentLevel);
         virtual bool operator==(PVField  *pv) ;
+        virtual bool operator!=(PVField  *pv) ;
     private:
         epicsInt16 value;
     };
@@ -66,5 +67,10 @@ namespace epics { namespace pvData {
         return getConvert()->equals(this,pvField);
     }
 
+    bool BasePVShort::operator!=(PVField  *pvField) 
+    {
+        return !(getConvert()->equals(this,pvField));
+    }
+
 }}
 #endif  /* BASEPVSHORT_H */
diff --git a/pvDataApp/factory/BasePVShortArray.h b/pvDataApp/factory/BasePVShortArray.h
index b7bcbe1..04a9dc9 100644
--- a/pvDataApp/factory/BasePVShortArray.h
+++ b/pvDataApp/factory/BasePVShortArray.h
@@ -34,6 +34,7 @@ namespace epics { namespace pvData {
         virtual void toString(StringBuilder buf);
         virtual void toString(StringBuilder buf,int indentLevel);
         virtual bool operator==(PVField  *pv) ;
+        virtual bool operator!=(PVField  *pv) ;
     private:
         epicsInt16 *value;
     };
@@ -149,5 +150,10 @@ namespace epics { namespace pvData {
     {
         return getConvert()->equals(this,pv);
     }
+
+    bool BasePVShortArray::operator!=(PVField  *pv) 
+    {
+        return !(getConvert()->equals(this,pv));
+    }
 }}
 #endif  /* BASEPVSHORTARRAY_H */
diff --git a/pvDataApp/factory/BasePVString.h b/pvDataApp/factory/BasePVString.h
index 22a0cca..52b57f7 100644
--- a/pvDataApp/factory/BasePVString.h
+++ b/pvDataApp/factory/BasePVString.h
@@ -27,6 +27,7 @@ namespace epics { namespace pvData {
         virtual void toString(StringBuilder buf);
         virtual void toString(StringBuilder buf,int indentLevel);
         virtual bool operator==(PVField  *pv) ;
+        virtual bool operator!=(PVField  *pv) ;
     private:
         String value;
     };
@@ -66,5 +67,10 @@ namespace epics { namespace pvData {
         return getConvert()->equals(this,pvField);
     }
 
+    bool BasePVString::operator!=(PVField  *pvField) 
+    {
+        return !(getConvert()->equals(this,pvField));
+    }
+
 }}
 #endif  /* BASEPVSTRING_H */
diff --git a/pvDataApp/factory/BasePVStringArray.h b/pvDataApp/factory/BasePVStringArray.h
index 9527b5f..2d9f92d 100644
--- a/pvDataApp/factory/BasePVStringArray.h
+++ b/pvDataApp/factory/BasePVStringArray.h
@@ -34,6 +34,7 @@ namespace epics { namespace pvData {
         virtual void toString(StringBuilder buf);
         virtual void toString(StringBuilder buf,int indentLevel);
         virtual bool operator==(PVField  *pv) ;
+        virtual bool operator!=(PVField  *pv) ;
     private:
         String *value;
     };
@@ -149,5 +150,10 @@ namespace epics { namespace pvData {
     {
         return getConvert()->equals(this,pv);
     }
+
+    bool BasePVStringArray::operator!=(PVField  *pv) 
+    {
+        return !(getConvert()->equals(this,pv));
+    }
 }}
 #endif  /* BASEPVSTRINGARRAY_H */
diff --git a/pvDataApp/factory/BasePVStructure.h b/pvDataApp/factory/BasePVStructure.h
index 0780c95..1f05ee1 100644
--- a/pvDataApp/factory/BasePVStructure.h
+++ b/pvDataApp/factory/BasePVStructure.h
@@ -193,6 +193,11 @@ namespace epics { namespace pvData {
         throw std::logic_error(notImplemented);
     }
 
+    bool PVStructure::operator!=(PVField  *pv) 
+    {
+        throw std::logic_error(notImplemented);
+    }
+
     class BasePVStructure : public PVStructure {
     public:
         BasePVStructure(PVStructure *parent,StructureConstPtr structure);
diff --git a/pvDataApp/factory/BasePVStructureArray.h b/pvDataApp/factory/BasePVStructureArray.h
index 1c09875..564a445 100644
--- a/pvDataApp/factory/BasePVStructureArray.h
+++ b/pvDataApp/factory/BasePVStructureArray.h
@@ -98,6 +98,11 @@ namespace epics { namespace pvData {
         throw std::logic_error(notImplemented);
     }
 
+    bool PVStructureArray::operator!=(PVField  *pv) 
+    {
+        throw std::logic_error(notImplemented);
+    }
+
     class BasePVStructureArray : public PVStructureArray {
     public:
         BasePVStructureArray(PVStructure *parent,
diff --git a/pvDataApp/factory/Convert.cpp b/pvDataApp/factory/Convert.cpp
index 23bb6ae..3d4aeef 100644
--- a/pvDataApp/factory/Convert.cpp
+++ b/pvDataApp/factory/Convert.cpp
@@ -13,6 +13,8 @@ namespace epics { namespace pvData {
 
 static Convert* convert = 0;
 
+static String trueString("true");
+static String falseString("false");
 static String logicError("Logic error. Should never get here.");
 static String notImplemented("not implemented");
 static String illegalScalarType("Illegal ScalarType");
@@ -387,7 +389,7 @@ int Convert::copyScalarArray(PVScalarArray *from, int offset,
         PVBooleanArray *pvto = (PVBooleanArray*)to;
         while(length>0) {
             int num = 0;
-            bool *data = 0;
+            BooleanArray data = 0;
             int fromOffset = 0;
             BooleanArrayData booleanArrayData = BooleanArrayData();
             num = pvfrom->get(offset,length,&booleanArrayData);
@@ -1247,8 +1249,106 @@ static bool arrayEquals(PVScalarArray *a,PVScalarArray *b)
             BooleanArrayData bdata = BooleanArrayData();
             aarray->get(0,length,&adata);
             barray->get(0,length,&bdata);
-            bool *avalue = adata.data;
-            bool *bvalue = bdata.data;
+            BooleanArray avalue = adata.data;
+            BooleanArray bvalue = bdata.data;
+            for(int i=0; i<length; i++) {
+                if(avalue[i]!=bvalue[i]) return epicsFalse;
+            }
+            return epicsTrue;
+        }
+        case pvByte: {
+            PVByteArray *aarray = (PVByteArray *)a;
+            PVByteArray *barray = (PVByteArray *)b;
+            ByteArrayData adata = ByteArrayData();
+            ByteArrayData bdata = ByteArrayData();
+            aarray->get(0,length,&adata);
+            barray->get(0,length,&bdata);
+            ByteArray avalue = adata.data;
+            ByteArray bvalue = bdata.data;
+            for(int i=0; i<length; i++) {
+                if(avalue[i]!=bvalue[i]) return epicsFalse;
+            }
+            return epicsTrue;
+        }
+        case pvShort: {
+            PVShortArray *aarray = (PVShortArray *)a;
+            PVShortArray *barray = (PVShortArray *)b;
+            ShortArrayData adata = ShortArrayData();
+            ShortArrayData bdata = ShortArrayData();
+            aarray->get(0,length,&adata);
+            barray->get(0,length,&bdata);
+            ShortArray avalue = adata.data;
+            ShortArray bvalue = bdata.data;
+            for(int i=0; i<length; i++) {
+                if(avalue[i]!=bvalue[i]) return epicsFalse;
+            }
+            return epicsTrue;
+        }
+        case pvInt: {
+            PVIntArray *aarray = (PVIntArray *)a;
+            PVIntArray *barray = (PVIntArray *)b;
+            IntArrayData adata = IntArrayData();
+            IntArrayData bdata = IntArrayData();
+            aarray->get(0,length,&adata);
+            barray->get(0,length,&bdata);
+            IntArray avalue = adata.data;
+            IntArray bvalue = bdata.data;
+            for(int i=0; i<length; i++) {
+                if(avalue[i]!=bvalue[i]) return epicsFalse;
+            }
+            return epicsTrue;
+        }
+        case pvLong: {
+            PVLongArray *aarray = (PVLongArray *)a;
+            PVLongArray *barray = (PVLongArray *)b;
+            LongArrayData adata = LongArrayData();
+            LongArrayData bdata = LongArrayData();
+            aarray->get(0,length,&adata);
+            barray->get(0,length,&bdata);
+            LongArray avalue = adata.data;
+            LongArray bvalue = bdata.data;
+            for(int i=0; i<length; i++) {
+                if(avalue[i]!=bvalue[i]) return epicsFalse;
+            }
+            return epicsTrue;
+        }
+        case pvFloat: {
+            PVFloatArray *aarray = (PVFloatArray *)a;
+            PVFloatArray *barray = (PVFloatArray *)b;
+            FloatArrayData adata = FloatArrayData();
+            FloatArrayData bdata = FloatArrayData();
+            aarray->get(0,length,&adata);
+            barray->get(0,length,&bdata);
+            FloatArray avalue = adata.data;
+            FloatArray bvalue = bdata.data;
+            for(int i=0; i<length; i++) {
+                if(avalue[i]!=bvalue[i]) return epicsFalse;
+            }
+            return epicsTrue;
+        }
+        case pvDouble: {
+            PVDoubleArray *aarray = (PVDoubleArray *)a;
+            PVDoubleArray *barray = (PVDoubleArray *)b;
+            DoubleArrayData adata = DoubleArrayData();
+            DoubleArrayData bdata = DoubleArrayData();
+            aarray->get(0,length,&adata);
+            barray->get(0,length,&bdata);
+            DoubleArray avalue = adata.data;
+            DoubleArray bvalue = bdata.data;
+            for(int i=0; i<length; i++) {
+                if(avalue[i]!=bvalue[i]) return epicsFalse;
+            }
+            return epicsTrue;
+        }
+        case pvString: {
+            PVStringArray *aarray = (PVStringArray *)a;
+            PVStringArray *barray = (PVStringArray *)b;
+            StringArrayData adata = StringArrayData();
+            StringArrayData bdata = StringArrayData();
+            aarray->get(0,length,&adata);
+            barray->get(0,length,&bdata);
+            String *avalue = adata.data;
+            String *bvalue = bdata.data;
             for(int i=0; i<length; i++) {
                 if(avalue[i]!=bvalue[i]) return epicsFalse;
             }
@@ -1261,12 +1361,40 @@ static bool arrayEquals(PVScalarArray *a,PVScalarArray *b)
 
 static bool structureArrayEquals(PVStructureArray *a,PVStructureArray *b)
 {
-    throw std::logic_error(notImplemented);
+    StructureConstPtr aStructure = a->getStructureArray()->getStructure();
+    StructureConstPtr bStructure = b->getStructureArray()->getStructure();
+    if(aStructure!=bStructure) return false;
+    if(a->getLength()!=b->getLength()) return false;
+    StructureArrayData aData = StructureArrayData();
+    StructureArrayData bData = StructureArrayData();
+    int length = a->getLength();
+    PVStructurePtrArray aArray = aData.data;
+    PVStructurePtrArray bArray = bData.data;
+    if(aArray==bArray) return true;
+    for(int i=0; i<length; i++) {
+        if(aArray[i]==0) {
+            if(bArray[i]==0) continue;
+            return false;
+        } else {
+            if(bArray[i]==0) return false;
+        }
+        if(aArray[i]!=bArray[i]) return false;
+    }
+    return true;
 }
 
 static bool structureEquals(PVStructure *a,PVStructure *b)
 {
-    throw std::logic_error(notImplemented);
+    StructureConstPtr aStructure = a->getStructure();
+    StructureConstPtr bStructure = a->getStructure();
+    int length = aStructure->getNumberFields();
+    if(length!=bStructure->getNumberFields()) return false;
+    PVFieldPtrArray aFields = a->getPVFields();
+    PVFieldPtrArray bFields = b->getPVFields();
+    for(int i=0; i<length; i++) {
+        if(aFields[i]!=bFields[i]) return false;
+    }
+    return true;
 }
 
 bool convertEquals(PVField *a,PVField *b)
@@ -1292,72 +1420,1629 @@ bool convertEquals(PVField *a,PVField *b)
 
 int convertFromByteArray(PVScalarArray *pv, int offset, int len,epicsInt8 from[], int fromOffset)
 {
-    throw std::logic_error(notImplemented);
+    ScalarType elemType = pv->getScalarArray()->getElementType();
+    int ntransfered = 0;
+    switch (elemType) {
+    case pvBoolean: {
+         String message("convert from byte[] to BooleanArray not legal");
+         throw std::invalid_argument(message);
+    }
+    case pvByte: {
+        PVByteArray *pvdata = (PVByteArray*) pv;
+        while (len > 0) {
+            int n = pvdata->put(offset, len, from, fromOffset);
+            if (n == 0)
+                break;
+            len -= n;
+            offset += n;
+            fromOffset += n;
+            ntransfered += n;
+        }
+        return ntransfered;
+    }
+    case pvShort: {
+        PVShortArray *pvdata = (PVShortArray*) pv;
+        epicsInt16 data[1];
+        while (len > 0) {
+            data[0] = (epicsInt16) from[fromOffset];
+            if (pvdata->put(offset, 1, data, 0) == 0)
+                return ntransfered;
+            --len;
+            ++ntransfered;
+            ++offset;
+            ++fromOffset;
+        }
+        return ntransfered;
+    }
+    case pvInt: {
+        PVIntArray *pvdata = (PVIntArray*) pv;
+        epicsInt32 data[1];
+        while (len > 0) {
+            data[0] = (epicsInt32) from[fromOffset];
+            if (pvdata->put(offset, 1, data, 0) == 0)
+                return ntransfered;
+            --len;
+            ++ntransfered;
+            ++offset;
+            ++fromOffset;
+        }
+        return ntransfered;
+    }
+    case pvLong: {
+        PVLongArray *pvdata = (PVLongArray*) pv;
+        epicsInt64 data[1];
+        while (len > 0) {
+            data[0] = (epicsInt64) from[fromOffset];
+            if (pvdata->put(offset, 1, data, 0) == 0)
+                return ntransfered;
+            --len;
+            ++ntransfered;
+            ++offset;
+            ++fromOffset;
+        }
+        return ntransfered;
+    }
+    case pvFloat: {
+        PVFloatArray *pvdata = (PVFloatArray*) pv;
+        float data[1];
+        while (len > 0) {
+            data[0] = (float) from[fromOffset];
+            if (pvdata->put(offset, 1, data, 0) == 0)
+                return ntransfered;
+            --len;
+            ++ntransfered;
+            ++offset;
+            ++fromOffset;
+        }
+        return ntransfered;
+    }
+    case pvDouble: {
+        PVDoubleArray *pvdata = (PVDoubleArray*) pv;
+        double data[1];
+        while (len > 0) {
+            data[0] = (double) from[fromOffset];
+            if (pvdata->put(offset, 1, data, 0) == 0)
+                return ntransfered;
+            --len;
+            ++ntransfered;
+            ++offset;
+            ++fromOffset;
+        }
+        return ntransfered;
+    }
+    case pvString: {
+         String message("convert from byte[] to StringArray not legal");
+         throw std::invalid_argument(message);
+    }
+    }
+    String message("Convert::convertFromByteArray should never get here");
+    throw std::logic_error(message);
 }
 
 int convertToByteArray(PVScalarArray * pv, int offset, int len,epicsInt8 to[], int toOffset)
 {
-    throw std::logic_error(notImplemented);
+    ScalarType elemType = pv->getScalarArray()->getElementType();
+    int ntransfered = 0;
+    switch (elemType) {
+    case pvBoolean: {
+        String message("convert BooleanArray to byte[]] not legal");
+        throw std::invalid_argument(message);
+    }
+    case pvByte: {
+        PVByteArray *pvdata = (PVByteArray*) pv;
+        ByteArrayData data = ByteArrayData();
+        while (len > 0) {
+            int num = 0;
+            num = pvdata->get(offset,len,&data);
+            if (num <= 0) break;
+            ByteArray dataArray = data.data;
+            int dataOffset = data.offset;
+            for(int i=0;i<num;i++) to[toOffset+i] = dataArray[dataOffset+1];
+            len -= num;
+            offset += num;
+            toOffset += num;
+            ntransfered += num;
+        }
+        return ntransfered;
+    }
+    case pvShort: {
+        PVShortArray *pvdata = (PVShortArray*) pv;
+        ShortArrayData data = ShortArrayData();
+        while (len > 0) {
+            int num = pvdata->get(offset, len, &data);
+            if (num == 0) break;
+            ShortArray dataArray = data.data;
+            int dataOffset = data.offset;
+            for (int i = 0; i < num; i++)
+                to[i + toOffset] = (epicsInt8) dataArray[i + dataOffset];
+            len -= num;
+            offset += num;
+            toOffset += num;
+            ntransfered += num;
+        }
+        return ntransfered;
+    }
+    case pvInt: {
+        PVIntArray *pvdata = (PVIntArray*) pv;
+        IntArrayData data = IntArrayData();
+        while (len > 0) {
+            int num = pvdata->get(offset, len, &data);
+            if (num == 0) break;
+            IntArray dataArray = data.data;
+            int dataOffset = data.offset;
+            for (int i = 0; i < num; i++)
+                to[i + toOffset] = (epicsInt8) dataArray[i + dataOffset];
+            len -= num;
+            offset += num;
+            toOffset += num;
+            ntransfered += num;
+        }
+        return ntransfered;
+    }
+    case pvLong: {
+        PVLongArray *pvdata = (PVLongArray*) pv;
+        LongArrayData data = LongArrayData();
+        while (len > 0) {
+            int num = pvdata->get(offset, len, &data);
+            if (num == 0)
+                break;
+            LongArray dataArray = data.data;
+            int dataOffset = data.offset;
+            for (int i = 0; i < num; i++)
+                to[i + toOffset] = (epicsInt8) dataArray[i + dataOffset];
+            len -= num;
+            offset += num;
+            toOffset += num;
+            ntransfered += num;
+        }
+        return ntransfered;
+    }
+    case pvFloat: {
+        PVFloatArray *pvdata = (PVFloatArray*) pv;
+        FloatArrayData data = FloatArrayData();
+        while (len > 0) {
+            int num = pvdata->get(offset, len, &data);
+            if (num == 0) break;
+            FloatArray dataArray = data.data;
+            int dataOffset = data.offset;
+            for (int i = 0; i < num; i++)
+                to[i + toOffset] = (epicsInt8) dataArray[i + dataOffset];
+            len -= num;
+            offset += num;
+            toOffset += num;
+            ntransfered += num;
+        }
+        return ntransfered;
+    }
+    case pvDouble: {
+        PVDoubleArray *pvdata = (PVDoubleArray*) pv;
+        DoubleArrayData data = DoubleArrayData();
+        while (len > 0) {
+            int num = pvdata->get(offset, len, &data);
+            if (num == 0)
+                break;
+            DoubleArray dataArray = data.data;
+            int dataOffset = data.offset;
+            for (int i = 0; i < num; i++)
+                to[i + toOffset] = (epicsInt8) dataArray[i + dataOffset];
+            len -= num;
+            offset += num;
+            toOffset += num;
+            ntransfered += num;
+        }
+        return ntransfered;
+    }
+    case pvString: {
+        String message("convert StringArray to byte[]] not legal");
+        throw std::invalid_argument(message);
+    }
+    }
+     String message("Convert::convertToByteArray should never get here");
+    throw std::logic_error(message);
 }
 
 int convertFromShortArray(PVScalarArray *pv, int offset, int len,epicsInt16 from[], int fromOffset)
 {
-    throw std::logic_error(notImplemented);
+    ScalarType elemType = pv->getScalarArray()->getElementType();
+    int ntransfered = 0;
+    switch (elemType) {
+    case pvBoolean: {
+         String message("convert from short[] to BooleanArray not legal");
+         throw std::invalid_argument(message);
+    }
+    case pvByte: {
+        PVByteArray *pvdata = (PVByteArray*) pv;
+        epicsInt8 data[1];
+        while (len > 0) {
+            data[0] = (epicsInt8) from[fromOffset];
+            if (pvdata->put(offset, 1, data, 0) == 0)
+                return ntransfered;
+            --len;
+            ++ntransfered;
+            ++offset;
+            ++fromOffset;
+        }
+        return ntransfered;
+    }
+    case pvShort: {
+        PVShortArray *pvdata = (PVShortArray*) pv;
+        while (len > 0) {
+            int n = pvdata->put(offset, len, from, fromOffset);
+            if (n == 0)
+                break;
+            len -= n;
+            offset += n;
+            fromOffset += n;
+            ntransfered += n;
+        }
+        return ntransfered;
+    }
+    case pvInt: {
+        PVIntArray *pvdata = (PVIntArray*) pv;
+        epicsInt32 data[1];
+        while (len > 0) {
+            data[0] = (epicsInt32) from[fromOffset];
+            if (pvdata->put(offset, 1, data, 0) == 0)
+                return ntransfered;
+            --len;
+            ++ntransfered;
+            ++offset;
+            ++fromOffset;
+        }
+        return ntransfered;
+    }
+    case pvLong: {
+        PVLongArray *pvdata = (PVLongArray*) pv;
+        epicsInt64 data[1];
+        while (len > 0) {
+            data[0] = (epicsInt64) from[fromOffset];
+            if (pvdata->put(offset, 1, data, 0) == 0)
+                return ntransfered;
+            --len;
+            ++ntransfered;
+            ++offset;
+            ++fromOffset;
+        }
+        return ntransfered;
+    }
+    case pvFloat: {
+        PVFloatArray *pvdata = (PVFloatArray*) pv;
+        float data[1];
+        while (len > 0) {
+            data[0] = (float) from[fromOffset];
+            if (pvdata->put(offset, 1, data, 0) == 0)
+                return ntransfered;
+            --len;
+            ++ntransfered;
+            ++offset;
+            ++fromOffset;
+        }
+        return ntransfered;
+    }
+    case pvDouble: {
+        PVDoubleArray *pvdata = (PVDoubleArray*) pv;
+        double data[1];
+        while (len > 0) {
+            data[0] = (double) from[fromOffset];
+            if (pvdata->put(offset, 1, data, 0) == 0)
+                return ntransfered;
+            --len;
+            ++ntransfered;
+            ++offset;
+            ++fromOffset;
+        }
+        return ntransfered;
+    }
+    case pvString: {
+         String message("convert from short[] to StringArray not legal");
+         throw std::invalid_argument(message);
+    }
+    }
+    String message("Convert::convertFromShortArray should never get here");
+    throw std::logic_error(message);
 }
 
 int convertToShortArray(PVScalarArray * pv, int offset, int len,epicsInt16 to[], int toOffset)
 {
-    throw std::logic_error(notImplemented);
+    ScalarType elemType = pv->getScalarArray()->getElementType();
+    int ntransfered = 0;
+    switch (elemType) {
+    case pvBoolean: {
+        String message("convert BooleanArray to short[]] not legal");
+        throw std::invalid_argument(message);
+    }
+    case pvByte: {
+        PVByteArray *pvdata = (PVByteArray*) pv;
+        ByteArrayData data = ByteArrayData();
+        while (len > 0) {
+            int num = 0;
+            num = pvdata->get(offset,len,&data);
+            if (num <= 0) break;
+            ByteArray dataArray = data.data;
+            int dataOffset = data.offset;
+            for(int i=0;i<num;i++) to[toOffset+i] = dataArray[dataOffset+1];
+            len -= num;
+            offset += num;
+            toOffset += num;
+            ntransfered += num;
+        }
+        return ntransfered;
+    }
+    case pvShort: {
+        PVShortArray *pvdata = (PVShortArray*) pv;
+        ShortArrayData data = ShortArrayData();
+        while (len > 0) {
+            int num = pvdata->get(offset, len, &data);
+            if (num == 0) break;
+            ShortArray dataArray = data.data;
+            int dataOffset = data.offset;
+            for (int i = 0; i < num; i++)
+                to[i + toOffset] = (epicsInt8) dataArray[i + dataOffset];
+            len -= num;
+            offset += num;
+            toOffset += num;
+            ntransfered += num;
+        }
+        return ntransfered;
+    }
+    case pvInt: {
+        PVIntArray *pvdata = (PVIntArray*) pv;
+        IntArrayData data = IntArrayData();
+        while (len > 0) {
+            int num = pvdata->get(offset, len, &data);
+            if (num == 0) break;
+            IntArray dataArray = data.data;
+            int dataOffset = data.offset;
+            for (int i = 0; i < num; i++)
+                to[i + toOffset] = (epicsInt8) dataArray[i + dataOffset];
+            len -= num;
+            offset += num;
+            toOffset += num;
+            ntransfered += num;
+        }
+        return ntransfered;
+    }
+    case pvLong: {
+        PVLongArray *pvdata = (PVLongArray*) pv;
+        LongArrayData data = LongArrayData();
+        while (len > 0) {
+            int num = pvdata->get(offset, len, &data);
+            if (num == 0)
+                break;
+            LongArray dataArray = data.data;
+            int dataOffset = data.offset;
+            for (int i = 0; i < num; i++)
+                to[i + toOffset] = (epicsInt8) dataArray[i + dataOffset];
+            len -= num;
+            offset += num;
+            toOffset += num;
+            ntransfered += num;
+        }
+        return ntransfered;
+    }
+    case pvFloat: {
+        PVFloatArray *pvdata = (PVFloatArray*) pv;
+        FloatArrayData data = FloatArrayData();
+        while (len > 0) {
+            int num = pvdata->get(offset, len, &data);
+            if (num == 0) break;
+            FloatArray dataArray = data.data;
+            int dataOffset = data.offset;
+            for (int i = 0; i < num; i++)
+                to[i + toOffset] = (epicsInt8) dataArray[i + dataOffset];
+            len -= num;
+            offset += num;
+            toOffset += num;
+            ntransfered += num;
+        }
+        return ntransfered;
+    }
+    case pvDouble: {
+        PVDoubleArray *pvdata = (PVDoubleArray*) pv;
+        DoubleArrayData data = DoubleArrayData();
+        while (len > 0) {
+            int num = pvdata->get(offset, len, &data);
+            if (num == 0)
+                break;
+            DoubleArray dataArray = data.data;
+            int dataOffset = data.offset;
+            for (int i = 0; i < num; i++)
+                to[i + toOffset] = (epicsInt8) dataArray[i + dataOffset];
+            len -= num;
+            offset += num;
+            toOffset += num;
+            ntransfered += num;
+        }
+        return ntransfered;
+    }
+    case pvString: {
+        String message("convert StringArray to short[]] not legal");
+        throw std::invalid_argument(message);
+    }
+    }
+     String message("Convert::convertToShortArray should never get here");
+    throw std::logic_error(message);
 }
 
 int convertFromIntArray(PVScalarArray *pv, int offset, int len,epicsInt32 from[], int fromOffset)
 {
-    throw std::logic_error(notImplemented);
+    ScalarType elemType = pv->getScalarArray()->getElementType();
+    int ntransfered = 0;
+    switch (elemType) {
+    case pvBoolean: {
+         String message("convert from int[] to BooleanArray not legal");
+         throw std::invalid_argument(message);
+    }
+    case pvByte: {
+        PVByteArray *pvdata = (PVByteArray*) pv;
+        epicsInt8 data[1];
+        while (len > 0) {
+            data[0] = (epicsInt8) from[fromOffset];
+            if (pvdata->put(offset, 1, data, 0) == 0)
+                return ntransfered;
+            --len;
+            ++ntransfered;
+            ++offset;
+            ++fromOffset;
+        }
+        return ntransfered;
+    }
+    case pvShort: {
+        PVShortArray *pvdata = (PVShortArray*) pv;
+        epicsInt16 data[1];
+        while (len > 0) {
+            data[0] = (epicsInt16) from[fromOffset];
+            if (pvdata->put(offset, 1, data, 0) == 0)
+                return ntransfered;
+            --len;
+            ++ntransfered;
+            ++offset;
+            ++fromOffset;
+        }
+        return ntransfered;
+    }
+    case pvInt: {
+        PVIntArray *pvdata = (PVIntArray*) pv;
+        while (len > 0) {
+            int n = pvdata->put(offset, len, from, fromOffset);
+            if (n == 0)
+                break;
+            len -= n;
+            offset += n;
+            fromOffset += n;
+            ntransfered += n;
+        }
+        return ntransfered;
+    }
+    case pvLong: {
+        PVLongArray *pvdata = (PVLongArray*) pv;
+        epicsInt64 data[1];
+        while (len > 0) {
+            data[0] = (epicsInt64) from[fromOffset];
+            if (pvdata->put(offset, 1, data, 0) == 0)
+                return ntransfered;
+            --len;
+            ++ntransfered;
+            ++offset;
+            ++fromOffset;
+        }
+        return ntransfered;
+    }
+    case pvFloat: {
+        PVFloatArray *pvdata = (PVFloatArray*) pv;
+        float data[1];
+        while (len > 0) {
+            data[0] = (float) from[fromOffset];
+            if (pvdata->put(offset, 1, data, 0) == 0)
+                return ntransfered;
+            --len;
+            ++ntransfered;
+            ++offset;
+            ++fromOffset;
+        }
+        return ntransfered;
+    }
+    case pvDouble: {
+        PVDoubleArray *pvdata = (PVDoubleArray*) pv;
+        double data[1];
+        while (len > 0) {
+            data[0] = (double) from[fromOffset];
+            if (pvdata->put(offset, 1, data, 0) == 0)
+                return ntransfered;
+            --len;
+            ++ntransfered;
+            ++offset;
+            ++fromOffset;
+        }
+        return ntransfered;
+    }
+    case pvString: {
+         String message("convert from int[] to StringArray not legal");
+         throw std::invalid_argument(message);
+    }
+    }
+    String message("Convert::convertFromIntArray should never get here");
+    throw std::logic_error(message);
 }
 
 int convertToIntArray(PVScalarArray * pv, int offset, int len,epicsInt32 to[], int toOffset)
 {
-    throw std::logic_error(notImplemented);
+    ScalarType elemType = pv->getScalarArray()->getElementType();
+    int ntransfered = 0;
+    switch (elemType) {
+    case pvBoolean: {
+        String message("convert BooleanArray to byte[]] not legal");
+        throw std::invalid_argument(message);
+    }
+    case pvByte: {
+        PVByteArray *pvdata = (PVByteArray*) pv;
+        ByteArrayData data = ByteArrayData();
+        while (len > 0) {
+            int num = 0;
+            num = pvdata->get(offset,len,&data);
+            if (num <= 0) break;
+            ByteArray dataArray = data.data;
+            int dataOffset = data.offset;
+            for(int i=0;i<num;i++) to[toOffset+i] = dataArray[dataOffset+1];
+            len -= num;
+            offset += num;
+            toOffset += num;
+            ntransfered += num;
+        }
+        return ntransfered;
+    }
+    case pvShort: {
+        PVShortArray *pvdata = (PVShortArray*) pv;
+        ShortArrayData data = ShortArrayData();
+        while (len > 0) {
+            int num = pvdata->get(offset, len, &data);
+            if (num == 0) break;
+            ShortArray dataArray = data.data;
+            int dataOffset = data.offset;
+            for (int i = 0; i < num; i++)
+                to[i + toOffset] = (epicsInt8) dataArray[i + dataOffset];
+            len -= num;
+            offset += num;
+            toOffset += num;
+            ntransfered += num;
+        }
+        return ntransfered;
+    }
+    case pvInt: {
+        PVIntArray *pvdata = (PVIntArray*) pv;
+        IntArrayData data = IntArrayData();
+        while (len > 0) {
+            int num = pvdata->get(offset, len, &data);
+            if (num == 0) break;
+            IntArray dataArray = data.data;
+            int dataOffset = data.offset;
+            for (int i = 0; i < num; i++)
+                to[i + toOffset] = (epicsInt8) dataArray[i + dataOffset];
+            len -= num;
+            offset += num;
+            toOffset += num;
+            ntransfered += num;
+        }
+        return ntransfered;
+    }
+    case pvLong: {
+        PVLongArray *pvdata = (PVLongArray*) pv;
+        LongArrayData data = LongArrayData();
+        while (len > 0) {
+            int num = pvdata->get(offset, len, &data);
+            if (num == 0)
+                break;
+            LongArray dataArray = data.data;
+            int dataOffset = data.offset;
+            for (int i = 0; i < num; i++)
+                to[i + toOffset] = (epicsInt8) dataArray[i + dataOffset];
+            len -= num;
+            offset += num;
+            toOffset += num;
+            ntransfered += num;
+        }
+        return ntransfered;
+    }
+    case pvFloat: {
+        PVFloatArray *pvdata = (PVFloatArray*) pv;
+        FloatArrayData data = FloatArrayData();
+        while (len > 0) {
+            int num = pvdata->get(offset, len, &data);
+            if (num == 0) break;
+            FloatArray dataArray = data.data;
+            int dataOffset = data.offset;
+            for (int i = 0; i < num; i++)
+                to[i + toOffset] = (epicsInt8) dataArray[i + dataOffset];
+            len -= num;
+            offset += num;
+            toOffset += num;
+            ntransfered += num;
+        }
+        return ntransfered;
+    }
+    case pvDouble: {
+        PVDoubleArray *pvdata = (PVDoubleArray*) pv;
+        DoubleArrayData data = DoubleArrayData();
+        while (len > 0) {
+            int num = pvdata->get(offset, len, &data);
+            if (num == 0)
+                break;
+            DoubleArray dataArray = data.data;
+            int dataOffset = data.offset;
+            for (int i = 0; i < num; i++)
+                to[i + toOffset] = (epicsInt8) dataArray[i + dataOffset];
+            len -= num;
+            offset += num;
+            toOffset += num;
+            ntransfered += num;
+        }
+        return ntransfered;
+    }
+    case pvString: {
+        String message("convert StringArray to int[]] not legal");
+        throw std::invalid_argument(message);
+    }
+    }
+     String message("Convert::convertToIntArray should never get here");
+    throw std::logic_error(message);
 }
 
 int convertFromLongArray(PVScalarArray *pv, int offset, int len,epicsInt64 from[], int fromOffset)
 {
-    throw std::logic_error(notImplemented);
+    ScalarType elemType = pv->getScalarArray()->getElementType();
+    int ntransfered = 0;
+    switch (elemType) {
+    case pvBoolean: {
+         String message("convert from long[] to BooleanArray not legal");
+         throw std::invalid_argument(message);
+    }
+    case pvByte: {
+        PVByteArray *pvdata = (PVByteArray*) pv;
+        epicsInt8 data[1];
+        while (len > 0) {
+            data[0] = (epicsInt8) from[fromOffset];
+            if (pvdata->put(offset, 1, data, 0) == 0)
+                return ntransfered;
+            --len;
+            ++ntransfered;
+            ++offset;
+            ++fromOffset;
+        }
+        return ntransfered;
+    }
+    case pvShort: {
+        PVShortArray *pvdata = (PVShortArray*) pv;
+        epicsInt16 data[1];
+        while (len > 0) {
+            data[0] = (epicsInt16) from[fromOffset];
+            if (pvdata->put(offset, 1, data, 0) == 0)
+                return ntransfered;
+            --len;
+            ++ntransfered;
+            ++offset;
+            ++fromOffset;
+        }
+        return ntransfered;
+    }
+    case pvInt: {
+        PVIntArray *pvdata = (PVIntArray*) pv;
+        epicsInt32 data[1];
+        while (len > 0) {
+            data[0] = (epicsInt32) from[fromOffset];
+            if (pvdata->put(offset, 1, data, 0) == 0)
+                return ntransfered;
+            --len;
+            ++ntransfered;
+            ++offset;
+            ++fromOffset;
+        }
+        return ntransfered;
+    }
+    case pvLong: {
+        PVLongArray *pvdata = (PVLongArray*) pv;
+        while (len > 0) {
+            int n = pvdata->put(offset, len, from, fromOffset);
+            if (n == 0)
+                break;
+            len -= n;
+            offset += n;
+            fromOffset += n;
+            ntransfered += n;
+        }
+        return ntransfered;
+    }
+    case pvFloat: {
+        PVFloatArray *pvdata = (PVFloatArray*) pv;
+        float data[1];
+        while (len > 0) {
+            data[0] = (float) from[fromOffset];
+            if (pvdata->put(offset, 1, data, 0) == 0)
+                return ntransfered;
+            --len;
+            ++ntransfered;
+            ++offset;
+            ++fromOffset;
+        }
+        return ntransfered;
+    }
+    case pvDouble: {
+        PVDoubleArray *pvdata = (PVDoubleArray*) pv;
+        double data[1];
+        while (len > 0) {
+            data[0] = (double) from[fromOffset];
+            if (pvdata->put(offset, 1, data, 0) == 0)
+                return ntransfered;
+            --len;
+            ++ntransfered;
+            ++offset;
+            ++fromOffset;
+        }
+        return ntransfered;
+    }
+    case pvString: {
+         String message("convert from long[] to StringArray not legal");
+         throw std::invalid_argument(message);
+    }
+    }
+    String message("Convert::convertFromLongArray should never get here");
+    throw std::logic_error(message);
 }
 
 int convertToLongArray(PVScalarArray * pv, int offset, int len,epicsInt64 to[], int toOffset)
 {
-    throw std::logic_error(notImplemented);
+    ScalarType elemType = pv->getScalarArray()->getElementType();
+    int ntransfered = 0;
+    switch (elemType) {
+    case pvBoolean: {
+        String message("convert BooleanArray to long[]] not legal");
+        throw std::invalid_argument(message);
+    }
+    case pvByte: {
+        PVByteArray *pvdata = (PVByteArray*) pv;
+        ByteArrayData data = ByteArrayData();
+        while (len > 0) {
+            int num = 0;
+            num = pvdata->get(offset,len,&data);
+            if (num <= 0) break;
+            ByteArray dataArray = data.data;
+            int dataOffset = data.offset;
+            for(int i=0;i<num;i++) to[toOffset+i] = dataArray[dataOffset+1];
+            len -= num;
+            offset += num;
+            toOffset += num;
+            ntransfered += num;
+        }
+        return ntransfered;
+    }
+    case pvShort: {
+        PVShortArray *pvdata = (PVShortArray*) pv;
+        ShortArrayData data = ShortArrayData();
+        while (len > 0) {
+            int num = pvdata->get(offset, len, &data);
+            if (num == 0) break;
+            ShortArray dataArray = data.data;
+            int dataOffset = data.offset;
+            for (int i = 0; i < num; i++)
+                to[i + toOffset] = (epicsInt8) dataArray[i + dataOffset];
+            len -= num;
+            offset += num;
+            toOffset += num;
+            ntransfered += num;
+        }
+        return ntransfered;
+    }
+    case pvInt: {
+        PVIntArray *pvdata = (PVIntArray*) pv;
+        IntArrayData data = IntArrayData();
+        while (len > 0) {
+            int num = pvdata->get(offset, len, &data);
+            if (num == 0) break;
+            IntArray dataArray = data.data;
+            int dataOffset = data.offset;
+            for (int i = 0; i < num; i++)
+                to[i + toOffset] = (epicsInt8) dataArray[i + dataOffset];
+            len -= num;
+            offset += num;
+            toOffset += num;
+            ntransfered += num;
+        }
+        return ntransfered;
+    }
+    case pvLong: {
+        PVLongArray *pvdata = (PVLongArray*) pv;
+        LongArrayData data = LongArrayData();
+        while (len > 0) {
+            int num = pvdata->get(offset, len, &data);
+            if (num == 0)
+                break;
+            LongArray dataArray = data.data;
+            int dataOffset = data.offset;
+            for (int i = 0; i < num; i++)
+                to[i + toOffset] = (epicsInt8) dataArray[i + dataOffset];
+            len -= num;
+            offset += num;
+            toOffset += num;
+            ntransfered += num;
+        }
+        return ntransfered;
+    }
+    case pvFloat: {
+        PVFloatArray *pvdata = (PVFloatArray*) pv;
+        FloatArrayData data = FloatArrayData();
+        while (len > 0) {
+            int num = pvdata->get(offset, len, &data);
+            if (num == 0) break;
+            FloatArray dataArray = data.data;
+            int dataOffset = data.offset;
+            for (int i = 0; i < num; i++)
+                to[i + toOffset] = (epicsInt8) dataArray[i + dataOffset];
+            len -= num;
+            offset += num;
+            toOffset += num;
+            ntransfered += num;
+        }
+        return ntransfered;
+    }
+    case pvDouble: {
+        PVDoubleArray *pvdata = (PVDoubleArray*) pv;
+        DoubleArrayData data = DoubleArrayData();
+        while (len > 0) {
+            int num = pvdata->get(offset, len, &data);
+            if (num == 0)
+                break;
+            DoubleArray dataArray = data.data;
+            int dataOffset = data.offset;
+            for (int i = 0; i < num; i++)
+                to[i + toOffset] = (epicsInt8) dataArray[i + dataOffset];
+            len -= num;
+            offset += num;
+            toOffset += num;
+            ntransfered += num;
+        }
+        return ntransfered;
+    }
+    case pvString: {
+        String message("convert StringArray to long[]] not legal");
+        throw std::invalid_argument(message);
+    }
+    }
+     String message("Convert::convertToLongArray should never get here");
+    throw std::logic_error(message);
 }
 
 int convertFromFloatArray(PVScalarArray *pv, int offset, int len,float from[], int fromOffset)
 {
-    throw std::logic_error(notImplemented);
+    ScalarType elemType = pv->getScalarArray()->getElementType();
+    int ntransfered = 0;
+    switch (elemType) {
+    case pvBoolean: {
+         String message("convert from float[] to BooleanArray not legal");
+         throw std::invalid_argument(message);
+    }
+    case pvByte: {
+        PVByteArray *pvdata = (PVByteArray*) pv;
+        epicsInt8 data[1];
+        while (len > 0) {
+            data[0] = (epicsInt8) from[fromOffset];
+            if (pvdata->put(offset, 1, data, 0) == 0)
+                return ntransfered;
+            --len;
+            ++ntransfered;
+            ++offset;
+            ++fromOffset;
+        }
+        return ntransfered;
+    }
+    case pvShort: {
+        PVShortArray *pvdata = (PVShortArray*) pv;
+        epicsInt16 data[1];
+        while (len > 0) {
+            data[0] = (epicsInt16) from[fromOffset];
+            if (pvdata->put(offset, 1, data, 0) == 0)
+                return ntransfered;
+            --len;
+            ++ntransfered;
+            ++offset;
+            ++fromOffset;
+        }
+        return ntransfered;
+    }
+    case pvInt: {
+        PVIntArray *pvdata = (PVIntArray*) pv;
+        epicsInt32 data[1];
+        while (len > 0) {
+            data[0] = (epicsInt32) from[fromOffset];
+            if (pvdata->put(offset, 1, data, 0) == 0)
+                return ntransfered;
+            --len;
+            ++ntransfered;
+            ++offset;
+            ++fromOffset;
+        }
+        return ntransfered;
+    }
+    case pvLong: {
+        PVLongArray *pvdata = (PVLongArray*) pv;
+        epicsInt64 data[1];
+        while (len > 0) {
+            data[0] = (epicsInt64) from[fromOffset];
+            if (pvdata->put(offset, 1, data, 0) == 0)
+                return ntransfered;
+            --len;
+            ++ntransfered;
+            ++offset;
+            ++fromOffset;
+        }
+        return ntransfered;
+    }
+    case pvFloat: {
+        PVFloatArray *pvdata = (PVFloatArray*) pv;
+        while (len > 0) {
+            int n = pvdata->put(offset, len, from, fromOffset);
+            if (n == 0)
+                break;
+            len -= n;
+            offset += n;
+            fromOffset += n;
+            ntransfered += n;
+        }
+        return ntransfered;
+    }
+    case pvDouble: {
+        PVDoubleArray *pvdata = (PVDoubleArray*) pv;
+        double data[1];
+        while (len > 0) {
+            data[0] = (double) from[fromOffset];
+            if (pvdata->put(offset, 1, data, 0) == 0)
+                return ntransfered;
+            --len;
+            ++ntransfered;
+            ++offset;
+            ++fromOffset;
+        }
+        return ntransfered;
+    }
+    case pvString: {
+         String message("convert from float[] to StringArray not legal");
+         throw std::invalid_argument(message);
+    }
+    }
+    String message("Convert::convertFromFloatArray should never get here");
+    throw std::logic_error(message);
 }
 
 int convertToFloatArray(PVScalarArray * pv, int offset, int len,float to[], int toOffset)
 {
-    throw std::logic_error(notImplemented);
+    ScalarType elemType = pv->getScalarArray()->getElementType();
+    int ntransfered = 0;
+    switch (elemType) {
+    case pvBoolean: {
+        String message("convert BooleanArray to float[]] not legal");
+        throw std::invalid_argument(message);
+    }
+    case pvByte: {
+        PVByteArray *pvdata = (PVByteArray*) pv;
+        ByteArrayData data = ByteArrayData();
+        while (len > 0) {
+            int num = 0;
+            num = pvdata->get(offset,len,&data);
+            if (num <= 0) break;
+            ByteArray dataArray = data.data;
+            int dataOffset = data.offset;
+            for(int i=0;i<num;i++) to[toOffset+i] = dataArray[dataOffset+1];
+            len -= num;
+            offset += num;
+            toOffset += num;
+            ntransfered += num;
+        }
+        return ntransfered;
+    }
+    case pvShort: {
+        PVShortArray *pvdata = (PVShortArray*) pv;
+        ShortArrayData data = ShortArrayData();
+        while (len > 0) {
+            int num = pvdata->get(offset, len, &data);
+            if (num == 0) break;
+            ShortArray dataArray = data.data;
+            int dataOffset = data.offset;
+            for (int i = 0; i < num; i++)
+                to[i + toOffset] = (epicsInt8) dataArray[i + dataOffset];
+            len -= num;
+            offset += num;
+            toOffset += num;
+            ntransfered += num;
+        }
+        return ntransfered;
+    }
+    case pvInt: {
+        PVIntArray *pvdata = (PVIntArray*) pv;
+        IntArrayData data = IntArrayData();
+        while (len > 0) {
+            int num = pvdata->get(offset, len, &data);
+            if (num == 0) break;
+            IntArray dataArray = data.data;
+            int dataOffset = data.offset;
+            for (int i = 0; i < num; i++)
+                to[i + toOffset] = (epicsInt8) dataArray[i + dataOffset];
+            len -= num;
+            offset += num;
+            toOffset += num;
+            ntransfered += num;
+        }
+        return ntransfered;
+    }
+    case pvLong: {
+        PVLongArray *pvdata = (PVLongArray*) pv;
+        LongArrayData data = LongArrayData();
+        while (len > 0) {
+            int num = pvdata->get(offset, len, &data);
+            if (num == 0)
+                break;
+            LongArray dataArray = data.data;
+            int dataOffset = data.offset;
+            for (int i = 0; i < num; i++)
+                to[i + toOffset] = (epicsInt8) dataArray[i + dataOffset];
+            len -= num;
+            offset += num;
+            toOffset += num;
+            ntransfered += num;
+        }
+        return ntransfered;
+    }
+    case pvFloat: {
+        PVFloatArray *pvdata = (PVFloatArray*) pv;
+        FloatArrayData data = FloatArrayData();
+        while (len > 0) {
+            int num = pvdata->get(offset, len, &data);
+            if (num == 0) break;
+            FloatArray dataArray = data.data;
+            int dataOffset = data.offset;
+            for (int i = 0; i < num; i++)
+                to[i + toOffset] = (epicsInt8) dataArray[i + dataOffset];
+            len -= num;
+            offset += num;
+            toOffset += num;
+            ntransfered += num;
+        }
+        return ntransfered;
+    }
+    case pvDouble: {
+        PVDoubleArray *pvdata = (PVDoubleArray*) pv;
+        DoubleArrayData data = DoubleArrayData();
+        while (len > 0) {
+            int num = pvdata->get(offset, len, &data);
+            if (num == 0)
+                break;
+            DoubleArray dataArray = data.data;
+            int dataOffset = data.offset;
+            for (int i = 0; i < num; i++)
+                to[i + toOffset] = (epicsInt8) dataArray[i + dataOffset];
+            len -= num;
+            offset += num;
+            toOffset += num;
+            ntransfered += num;
+        }
+        return ntransfered;
+    }
+    case pvString: {
+        String message("convert StringArray to float[]] not legal");
+        throw std::invalid_argument(message);
+    }
+    }
+     String message("Convert::convertToFloatArray should never get here");
+    throw std::logic_error(message);
 }
 
 int convertFromDoubleArray(PVScalarArray *pv, int offset, int len,double from[], int fromOffset)
 {
-    throw std::logic_error(notImplemented);
+    ScalarType elemType = pv->getScalarArray()->getElementType();
+    int ntransfered = 0;
+    switch (elemType) {
+    case pvBoolean: {
+         String message("convert from double[] to BooleanArray not legal");
+         throw std::invalid_argument(message);
+    }
+    case pvByte: {
+        PVByteArray *pvdata = (PVByteArray*) pv;
+        epicsInt8 data[1];
+        while (len > 0) {
+            data[0] = (epicsInt8) from[fromOffset];
+            if (pvdata->put(offset, 1, data, 0) == 0)
+                return ntransfered;
+            --len;
+            ++ntransfered;
+            ++offset;
+            ++fromOffset;
+        }
+        return ntransfered;
+    }
+    case pvShort: {
+        PVShortArray *pvdata = (PVShortArray*) pv;
+        epicsInt16 data[1];
+        while (len > 0) {
+            data[0] = (epicsInt16) from[fromOffset];
+            if (pvdata->put(offset, 1, data, 0) == 0)
+                return ntransfered;
+            --len;
+            ++ntransfered;
+            ++offset;
+            ++fromOffset;
+        }
+        return ntransfered;
+    }
+    case pvInt: {
+        PVIntArray *pvdata = (PVIntArray*) pv;
+        epicsInt32 data[1];
+        while (len > 0) {
+            data[0] = (epicsInt32) from[fromOffset];
+            if (pvdata->put(offset, 1, data, 0) == 0)
+                return ntransfered;
+            --len;
+            ++ntransfered;
+            ++offset;
+            ++fromOffset;
+        }
+        return ntransfered;
+    }
+    case pvLong: {
+        PVLongArray *pvdata = (PVLongArray*) pv;
+        epicsInt64 data[1];
+        while (len > 0) {
+            data[0] = (epicsInt64) from[fromOffset];
+            if (pvdata->put(offset, 1, data, 0) == 0)
+                return ntransfered;
+            --len;
+            ++ntransfered;
+            ++offset;
+            ++fromOffset;
+        }
+        return ntransfered;
+    }
+    case pvFloat: {
+        PVFloatArray *pvdata = (PVFloatArray*) pv;
+        float data[1];
+        while (len > 0) {
+            data[0] = (float) from[fromOffset];
+            if (pvdata->put(offset, 1, data, 0) == 0)
+                return ntransfered;
+            --len;
+            ++ntransfered;
+            ++offset;
+            ++fromOffset;
+        }
+        return ntransfered;
+    }
+    case pvDouble: {
+        PVDoubleArray *pvdata = (PVDoubleArray*) pv;
+        while (len > 0) {
+            int n = pvdata->put(offset, len, from, fromOffset);
+            if (n == 0)
+                break;
+            len -= n;
+            offset += n;
+            fromOffset += n;
+            ntransfered += n;
+        }
+        return ntransfered;
+    }
+    case pvString: {
+         String message("convert from double[] to StringArray not legal");
+         throw std::invalid_argument(message);
+    }
+    }
+    String message("Convert::convertFromDoubleArray should never get here");
+    throw std::logic_error(message);
 }
 
 int convertToDoubleArray(PVScalarArray * pv, int offset, int len,double to[], int toOffset)
 {
-    throw std::logic_error(notImplemented);
+    ScalarType elemType = pv->getScalarArray()->getElementType();
+    int ntransfered = 0;
+    switch (elemType) {
+    case pvBoolean: {
+        String message("convert BooleanArray to float[]] not legal");
+        throw std::invalid_argument(message);
+    }
+    case pvByte: {
+        PVByteArray *pvdata = (PVByteArray*) pv;
+        ByteArrayData data = ByteArrayData();
+        while (len > 0) {
+            int num = 0;
+            num = pvdata->get(offset,len,&data);
+            if (num <= 0) break;
+            ByteArray dataArray = data.data;
+            int dataOffset = data.offset;
+            for(int i=0;i<num;i++) to[toOffset+i] = dataArray[dataOffset+1];
+            len -= num;
+            offset += num;
+            toOffset += num;
+            ntransfered += num;
+        }
+        return ntransfered;
+    }
+    case pvShort: {
+        PVShortArray *pvdata = (PVShortArray*) pv;
+        ShortArrayData data = ShortArrayData();
+        while (len > 0) {
+            int num = pvdata->get(offset, len, &data);
+            if (num == 0) break;
+            ShortArray dataArray = data.data;
+            int dataOffset = data.offset;
+            for (int i = 0; i < num; i++)
+                to[i + toOffset] = (epicsInt8) dataArray[i + dataOffset];
+            len -= num;
+            offset += num;
+            toOffset += num;
+            ntransfered += num;
+        }
+        return ntransfered;
+    }
+    case pvInt: {
+        PVIntArray *pvdata = (PVIntArray*) pv;
+        IntArrayData data = IntArrayData();
+        while (len > 0) {
+            int num = pvdata->get(offset, len, &data);
+            if (num == 0) break;
+            IntArray dataArray = data.data;
+            int dataOffset = data.offset;
+            for (int i = 0; i < num; i++)
+                to[i + toOffset] = (epicsInt8) dataArray[i + dataOffset];
+            len -= num;
+            offset += num;
+            toOffset += num;
+            ntransfered += num;
+        }
+        return ntransfered;
+    }
+    case pvLong: {
+        PVLongArray *pvdata = (PVLongArray*) pv;
+        LongArrayData data = LongArrayData();
+        while (len > 0) {
+            int num = pvdata->get(offset, len, &data);
+            if (num == 0)
+                break;
+            LongArray dataArray = data.data;
+            int dataOffset = data.offset;
+            for (int i = 0; i < num; i++)
+                to[i + toOffset] = (epicsInt8) dataArray[i + dataOffset];
+            len -= num;
+            offset += num;
+            toOffset += num;
+            ntransfered += num;
+        }
+        return ntransfered;
+    }
+    case pvFloat: {
+        PVFloatArray *pvdata = (PVFloatArray*) pv;
+        FloatArrayData data = FloatArrayData();
+        while (len > 0) {
+            int num = pvdata->get(offset, len, &data);
+            if (num == 0) break;
+            FloatArray dataArray = data.data;
+            int dataOffset = data.offset;
+            for (int i = 0; i < num; i++)
+                to[i + toOffset] = (epicsInt8) dataArray[i + dataOffset];
+            len -= num;
+            offset += num;
+            toOffset += num;
+            ntransfered += num;
+        }
+        return ntransfered;
+    }
+    case pvDouble: {
+        PVDoubleArray *pvdata = (PVDoubleArray*) pv;
+        DoubleArrayData data = DoubleArrayData();
+        while (len > 0) {
+            int num = pvdata->get(offset, len, &data);
+            if (num == 0)
+                break;
+            DoubleArray dataArray = data.data;
+            int dataOffset = data.offset;
+            for (int i = 0; i < num; i++)
+                to[i + toOffset] = (epicsInt8) dataArray[i + dataOffset];
+            len -= num;
+            offset += num;
+            toOffset += num;
+            ntransfered += num;
+        }
+        return ntransfered;
+    }
+    case pvString: {
+        String message("convert StringArray to double[]] not legal");
+        throw std::invalid_argument(message);
+    }
+    }
+    String message("Convert::convertToDoubleArray should never get here");
+    throw std::logic_error(message);
+}
+
+static String removeWhiteSpace(String string) {
+    return string;
 }
 
 int convertFromStringArray(PVScalarArray *pv, int offset, int len,String from[], int fromOffset)
 {
-    throw std::logic_error(notImplemented);
+    ScalarType elemType = pv->getScalarArray()->getElementType();
+    int ntransfered = 0;
+    switch (elemType) {
+    case pvBoolean: {
+        PVBooleanArray *pvdata = (PVBooleanArray*) pv;
+        bool data[1];
+        while (len > 0) {
+            String fromString = removeWhiteSpace(from[fromOffset]);
+            data[0] = (fromString.compare("true")==0) ? true : false;
+            if (pvdata->put(offset, 1, data, 0) == 0)
+                return ntransfered;
+            --len;
+            ++ntransfered;
+            ++offset;
+            ++fromOffset;
+        }
+        return ntransfered;
+    }
+    case pvByte: {
+        PVByteArray *pvdata = (PVByteArray*) pv;
+        epicsInt8 data[1];
+        while (len > 0) {
+            String fromString = removeWhiteSpace(from[fromOffset]);
+            int ival;
+            sscanf(fromString.c_str(),"%d",&ival);
+            data[0] = ival;
+            if (pvdata->put(offset, 1, data, 0) == 0)
+                return ntransfered;
+            --len;
+            ++ntransfered;
+            ++offset;
+            ++fromOffset;
+        }
+        return ntransfered;
+    }
+    case pvShort: {
+        PVShortArray *pvdata = (PVShortArray*) pv;
+        epicsInt16 data[1];
+        while (len > 0) {
+            String fromString = removeWhiteSpace(from[fromOffset]);
+            int ival;
+            sscanf(fromString.c_str(),"%d",&ival);
+            data[0] = ival;
+            if (pvdata->put(offset, 1, data, 0) == 0)
+                return ntransfered;
+            --len;
+            ++ntransfered;
+            ++offset;
+            ++fromOffset;
+        }
+        return ntransfered;
+    }
+    case pvInt: {
+        PVIntArray *pvdata = (PVIntArray*) pv;
+        epicsInt32 data[1];
+        while (len > 0) {
+            String fromString = removeWhiteSpace(from[fromOffset]);
+            int ival;
+            sscanf(fromString.c_str(),"%d",&ival);
+            data[0] = ival;
+            if (pvdata->put(offset, 1, data, 0) == 0)
+                return ntransfered;
+            --len;
+            ++ntransfered;
+            ++offset;
+            ++fromOffset;
+        }
+        return ntransfered;
+    }
+    case pvLong: {
+        PVLongArray *pvdata = (PVLongArray*) pv;
+        epicsInt64 data[1];
+        while (len > 0) {
+            String fromString = removeWhiteSpace(from[fromOffset]);
+            long int ival;
+            sscanf(fromString.c_str(),"%ld",&ival);
+            data[0] = ival;
+            if (pvdata->put(offset, 1, data, 0) == 0)
+                return ntransfered;
+            --len;
+            ++ntransfered;
+            ++offset;
+            ++fromOffset;
+        }
+        return ntransfered;
+    }
+    case pvFloat: {
+        PVFloatArray *pvdata = (PVFloatArray*) pv;
+        float data[1];
+        while (len > 0) {
+            String fromString = removeWhiteSpace(from[fromOffset]);
+            float fval;
+            sscanf(fromString.c_str(),"%f",&fval);
+            data[0] = fval;
+            if (pvdata->put(offset, 1, data, 0) == 0)
+                return ntransfered;
+            --len;
+            ++ntransfered;
+            ++offset;
+            ++fromOffset;
+        }
+        return ntransfered;
+    }
+    case pvDouble: {
+        PVDoubleArray *pvdata = (PVDoubleArray*) pv;
+        double data[1];
+        while (len > 0) {
+            String fromString = removeWhiteSpace(from[fromOffset]);
+            double fval;
+            sscanf(fromString.c_str(),"%lf",&fval);
+            data[0] = fval;
+            if (pvdata->put(offset, 1, data, 0) == 0)
+                return ntransfered;
+            --len;
+            ++ntransfered;
+            ++offset;
+            ++fromOffset;
+        }
+        return ntransfered;
+    }
+    case pvString:
+        PVStringArray *pvdata = (PVStringArray*) pv;
+        while (len > 0) {
+            int n = pvdata->put(offset, len, from, fromOffset);
+            if (n == 0)
+                break;
+            len -= n;
+            offset += n;
+            fromOffset += n;
+            ntransfered += n;
+        }
+        return ntransfered;
+    }
+    String message("Convert::convertFromStringArray should never get here");
+    throw std::logic_error(message);
 }
 
 int convertToStringArray(PVScalarArray * pv, int offset, int len,String to[], int toOffset)
 {
-    throw std::logic_error(notImplemented);
+    ScalarType elementType = pv->getScalarArray()->getElementType();
+    int ncopy = pv->getLength();
+    if (ncopy > len) ncopy = len;
+    int num = ncopy;
+    switch (elementType) {
+    case pvBoolean: {
+        PVBooleanArray *pvdata = (PVBooleanArray*) pv;
+        BooleanArrayData data = BooleanArrayData();
+        for (int i = 0; i < num; i++) {
+            if (pvdata->get(offset + i, 1, &data) == 1) {
+                BooleanArray dataArray = data.data;
+                bool value = dataArray[data.offset];
+                to[toOffset + i] = value ? trueString : falseString;
+            } else {
+                to[toOffset + i] = "bad pv";
+            }
+        }
+    }
+    break;
+    case pvByte: {
+        PVByteArray *pvdata = (PVByteArray*) pv;
+        ByteArrayData data = ByteArrayData();
+        char cr[30];
+        for (int i = 0; i < num; i++) {
+            if (pvdata->get(offset + i, 1, &data) == 1) {
+                ByteArray dataArray = data.data;
+                int ival = dataArray[data.offset];
+                sprintf(cr,"%d",ival);
+                to[toOffset + i] = String(cr);
+            } else {
+                to[toOffset + i] = "bad pv";
+            }
+        }
+    }
+    break;
+    case pvShort: {
+        PVShortArray *pvdata = (PVShortArray*) pv;
+        ShortArrayData data = ShortArrayData();
+        char cr[30];
+        for (int i = 0; i < num; i++) {
+            if (pvdata->get(offset + i, 1, &data) == 1) {
+                ShortArray dataArray = data.data;
+                int ival = dataArray[data.offset];
+                sprintf(cr,"%d",ival);
+                to[toOffset + i] = String(cr);
+            } else {
+                to[toOffset + i] = "bad pv";
+            }
+        }
+    }
+    break;
+    case pvInt: {
+        PVIntArray *pvdata = (PVIntArray*) pv;
+        IntArrayData data = IntArrayData();
+        char cr[30];
+        for (int i = 0; i < num; i++) {
+            if (pvdata->get(offset + i, 1, &data) == 1) {
+                IntArray dataArray = data.data;
+                int ival = dataArray[data.offset];
+                sprintf(cr,"%d",ival);
+                to[toOffset + i] = String(cr);
+            } else {
+                to[toOffset + i] = "bad pv";
+            }
+        }
+    }
+    break;
+    case pvLong: {
+        PVLongArray *pvdata = (PVLongArray*) pv;
+        LongArrayData data = LongArrayData();
+        char cr[30];
+        for (int i = 0; i < num; i++) {
+            if (pvdata->get(offset + i, 1, &data) == 1) {
+                LongArray dataArray = data.data;
+                long int ival = dataArray[data.offset];
+                sprintf(cr,"%ld",ival);
+                to[toOffset + i] = String(cr);
+            } else {
+                to[toOffset + i] = "bad pv";
+            }
+        }
+    }
+    break;
+    case pvFloat: {
+        PVFloatArray *pvdata = (PVFloatArray*) pv;
+        FloatArrayData data = FloatArrayData();
+        char cr[30];
+        for (int i = 0; i < num; i++) {
+            if (pvdata->get(offset + i, 1, &data) == 1) {
+                FloatArray dataArray = data.data;
+                float fval = dataArray[data.offset];
+                sprintf(cr,"%e",fval);
+                to[toOffset + i] = String(cr);
+            } else {
+                to[toOffset + i] = "bad pv";
+            }
+        }
+    }
+    break;
+    case pvDouble: {
+        PVDoubleArray *pvdata = (PVDoubleArray*) pv;
+        DoubleArrayData data = DoubleArrayData();
+        char cr[30];
+        for (int i = 0; i < num; i++) {
+            if (pvdata->get(offset + i, 1, &data) == 1) {
+                DoubleArray dataArray = data.data;
+                double fval = dataArray[data.offset];
+                sprintf(cr,"%e",fval);
+                to[toOffset + i] = String(cr);
+            } else {
+                to[toOffset + i] = "bad pv";
+            }
+        }
+    }
+    break;
+    case pvString: {
+        PVStringArray *pvdata = (PVStringArray*) pv;
+        while (num > 0) {
+            int numnow = 0;
+            StringArray dataArray = 0;
+            int dataOffset = 0;
+            StringArrayData stringArrayData = StringArrayData();
+            numnow = pvdata->get(offset, num, &stringArrayData);
+            dataArray = stringArrayData.data;
+            dataOffset = stringArrayData.offset;
+            if (numnow <= 0) {
+                for (int i = 0; i < num; i++)
+                    to[toOffset + i] = "bad pv";
+                break;
+            }
+            for(int i=0; i<num; i++) to[toOffset+i] = dataArray[dataOffset+i];
+            num -= numnow;
+            offset += numnow;
+            toOffset += numnow;
+        }
+    }
+    break;
+    default:
+        String message("Convert::convertToStringArray should never get here");
+        throw std::logic_error(message);
+    }
+    return ncopy;
 }
 
 
@@ -1439,7 +3124,23 @@ void convertToString(StringBuilder buffer,PVField * pv,int indentLevel)
 
 void convertStructure(StringBuilder buffer,PVStructure *data,int indentLevel)
 {
-    throw std::logic_error(notImplemented);
+    convert->newLine(buffer, indentLevel);
+    *buffer += "structure {";
+    char buff[30];
+    PVFieldPtrArray fieldsData = data->getPVFields();
+    if (fieldsData != 0) {
+        int length = data->getStructure()->getNumberFields();
+        for(int i=0; i<length; i++) {
+            PVField *fieldField = fieldsData[i];
+            FieldConstPtr fieldnow = fieldField->getField();
+            convert->newLine(buffer, indentLevel + 1);
+            sprintf(buff,"%s = ",fieldnow->getFieldName().c_str());
+            *buffer += buff;
+            convert->getString(buffer,fieldField,indentLevel + 1);
+        }
+    }
+    convert->newLine(buffer, indentLevel);
+    *buffer += "}";
 }
 
 void convertArray(StringBuilder buffer,PVScalarArray * pv,int indentLevel)
@@ -1455,7 +3156,7 @@ void convertArray(StringBuilder buffer,PVScalarArray * pv,int indentLevel)
                 if(i!=0) *buffer += ",";
                 int num = pvdata->get(i,1,&data);
                 if(num==1) {
-                     bool * value = data.data;
+                     BooleanArray  value = data.data;
                      if(value[data.offset]) {
                          *buffer += "true";
                      } else {
diff --git a/pvDataApp/misc/bitSet.cpp b/pvDataApp/misc/bitSet.cpp
index 30d05de..88b17eb 100644
--- a/pvDataApp/misc/bitSet.cpp
+++ b/pvDataApp/misc/bitSet.cpp
@@ -1,3 +1,5 @@
+#include "string.h"
+#include "stdio.h"
 #include "bitSet.h"
 
 namespace epics { namespace pvData {
diff --git a/pvDataApp/pv/pvData.h b/pvDataApp/pv/pvData.h
index 171b2c1..7d994b0 100644
--- a/pvDataApp/pv/pvData.h
+++ b/pvDataApp/pv/pvData.h
@@ -81,6 +81,7 @@ namespace epics { namespace pvData {
         virtual void toString(StringBuilder buf) ;
         virtual void toString(StringBuilder buf,int indentLevel) ;
         virtual bool operator==(PVField *pv) = 0;
+        virtual bool operator!=(PVField *pv) = 0;
     protected:
         PVField(PVStructure *parent,FieldConstPtr field);
         void replaceStructure();
@@ -170,6 +171,7 @@ namespace epics { namespace pvData {
         virtual void toString(StringBuilder buf) = 0;
         virtual void toString(StringBuilder buf,int indentLevel) = 0;
         virtual bool operator==(PVField *pv) = 0;
+        virtual bool operator!=(PVField *pv) = 0;
     protected:
         PVStructureArray(PVStructure *parent,
             StructureArrayConstPtr structureArray);
@@ -208,6 +210,7 @@ namespace epics { namespace pvData {
         virtual void toString(StringBuilder buf) ;
         virtual void toString(StringBuilder buf,int indentLevel) ;
         virtual bool operator==(PVField *pv) ;
+        virtual bool operator!=(PVField *pv) ;
         virtual void serialize(
             ByteBuffer *pbuffer,SerializableControl *pflusher) ;
         virtual void deserialize(
diff --git a/pvDataApp/test/testBitSet.cpp b/pvDataApp/test/testBitSet.cpp
index e294a19..7c05567 100644
--- a/pvDataApp/test/testBitSet.cpp
+++ b/pvDataApp/test/testBitSet.cpp
@@ -6,7 +6,7 @@
 #include <stddef.h>
 #include <string.h>
 #include <stdio.h>
-#include "BitSet.h"
+#include "bitSet.h"
 
 
 #include <epicsAssert.h>