diff --git a/pvDataApp/factory/Convert.cpp b/pvDataApp/factory/Convert.cpp
index c1f01f9..7a43cd8 100644
--- a/pvDataApp/factory/Convert.cpp
+++ b/pvDataApp/factory/Convert.cpp
@@ -24,56 +24,6 @@ using std::size_t;
 namespace epics { namespace pvData { 
 
 
-static void newLineImpl(StringBuilder buffer, int indentLevel)
-{
-    *buffer += "\n";
-    for(int i=0; i<indentLevel; i++) *buffer += "    ";
-}
-
-static size_t convertFromByteArray(PVScalarArray * pv, size_t offset,
-    size_t len,const int8 from[], size_t fromOffset);
-static size_t convertToByteArray(PVScalarArray *pv, size_t offset,
-    size_t len,int8 to[], size_t toOffset);
-static size_t convertFromShortArray(PVScalarArray *pv, size_t offset,
-    size_t len,const int16 from[], size_t fromOffset);
-static size_t convertToShortArray(PVScalarArray *pv, size_t offset,
-    size_t len,int16 to[], size_t toOffset);
-static size_t convertFromIntArray(PVScalarArray *pv, size_t offset,
-    size_t len,const int32 from[], size_t fromOffset);
-static size_t convertToIntArray(PVScalarArray *pv, size_t offset,
-    size_t len,int32 to[], size_t toOffset);
-static size_t convertFromLongArray(PVScalarArray *pv, size_t offset,
-    size_t len,const int64 from[], size_t fromOffset);
-static size_t convertToLongArray(PVScalarArray * pv, size_t offset,
-    size_t len,int64 to[], size_t toOffset);
-static size_t convertFromUByteArray(PVScalarArray * pv, size_t offset,
-    size_t len,const uint8 from[], size_t fromOffset);
-static size_t convertToUByteArray(PVScalarArray *pv, size_t offset,
-    size_t len,uint8 to[], size_t toOffset);
-static size_t convertFromUShortArray(PVScalarArray *pv, size_t offset,
-    size_t len,const uint16 from[], size_t fromOffset);
-static size_t convertToUShortArray(PVScalarArray *pv, size_t offset,
-    size_t len,uint16 to[], size_t toOffset);
-static size_t convertFromUIntArray(PVScalarArray *pv, size_t offset,
-    size_t len,const uint32 from[], size_t fromOffset);
-static size_t convertToUIntArray(PVScalarArray *pv, size_t offset,
-    size_t len,uint32 to[], size_t toOffset);
-static size_t convertFromULongArray(PVScalarArray *pv, size_t offset,
-    size_t len,const uint64 from[], size_t fromOffset);
-static size_t convertToULongArray(PVScalarArray * pv, size_t offset,
-    size_t len,uint64 to[], size_t toOffset);
-static size_t convertFromFloatArray(PVScalarArray *pv, size_t offset,
-    size_t len,const float from[], size_t fromOffset);
-static size_t convertToFloatArray(PVScalarArray * pv, size_t offset,
-    size_t len,float to[], size_t toOffset);
-static size_t convertFromDoubleArray(PVScalarArray *pv, size_t offset,
-    size_t len,const double from[], size_t fromOffset);
-static size_t convertToDoubleArray(PVScalarArray *pv, size_t offset,
-    size_t len,double to[], size_t toOffset);
-
-
-static std::vector<String> split(String commaSeparatedList);
-
 static std::vector<String> split(String commaSeparatedList) {
     String::size_type numValues = 1;
     String::size_type index=0;
@@ -447,677 +397,10 @@ void Convert::copyStructureArray(
     to->put(0,from->getLength(),from->getVector(),0);
 }
 
-size_t Convert::toByteArray(PVScalarArrayPtr const &pv, size_t offset, size_t length,
-    int8 to[], size_t toOffset)
-{
-    return convertToByteArray(pv.get(), offset, length, to, toOffset);
-}
-
-size_t Convert::toShortArray(PVScalarArrayPtr const &pv, size_t offset, size_t length,
-    int16 to[], size_t toOffset)
-{
-    return convertToShortArray(pv.get(), offset, length, to, toOffset);
-}
-
-size_t Convert::toIntArray(PVScalarArrayPtr const &pv, size_t offset, size_t length,
-    int32 to[], size_t toOffset)
-{
-    return convertToIntArray(pv.get(), offset, length, to, toOffset);
-}
-
-size_t Convert::toLongArray(PVScalarArrayPtr const &pv, size_t offset, size_t length,
-    int64 to[], size_t toOffset)
-{
-    return convertToLongArray(pv.get(), offset, length, to, toOffset);
-}
-
-size_t Convert::toUByteArray(PVScalarArrayPtr const &pv, size_t offset, size_t length,
-    uint8 to[], size_t toOffset)
-{
-    return convertToUByteArray(pv.get(), offset, length, to, toOffset);
-}
-
-size_t Convert::toUShortArray(PVScalarArrayPtr const &pv, size_t offset, size_t length,
-    uint16 to[], size_t toOffset)
-{
-    return convertToUShortArray(pv.get(), offset, length, to, toOffset);
-}
-
-size_t Convert::toUIntArray(PVScalarArrayPtr const &pv, size_t offset, size_t length,
-    uint32 to[], size_t toOffset)
-{
-    return convertToUIntArray(pv.get(), offset, length, to, toOffset);
-}
-
-size_t Convert::toULongArray(PVScalarArrayPtr const &pv, size_t offset, size_t length,
-    uint64 to[], size_t toOffset)
-{
-    return convertToULongArray(pv.get(), offset, length, to, toOffset);
-}
-
-size_t Convert::toFloatArray(PVScalarArrayPtr const &pv, size_t offset, size_t length,
-    float to[], size_t toOffset)
-{
-    return convertToFloatArray(pv.get(), offset, length, to, toOffset);
-}
-
-size_t Convert::toDoubleArray(PVScalarArrayPtr const &pv, size_t offset, size_t length,
-    double to[], size_t toOffset)
-{
-    return convertToDoubleArray(pv.get(), offset, length, to, toOffset);
-}
-
-size_t Convert::fromByteArray(PVScalarArrayPtr &pv, size_t offset, size_t length,
-    const int8 from[], size_t fromOffset)
-{
-    return convertFromByteArray(pv.get(), offset, length, from, fromOffset);
-}
-
-size_t Convert::fromByteArray(PVScalarArrayPtr &pv, size_t offset, size_t length,
-    const ByteArray & from, size_t fromOffset)
-{
-    return convertFromByteArray(pv.get(), offset, length, get(from), fromOffset);
-}
-
-size_t Convert::fromShortArray(PVScalarArrayPtr &pv, size_t offset, size_t length,
-    const int16 from[], size_t fromOffset)
-{
-    return convertFromShortArray(pv.get(), offset, length, from, fromOffset);
-}
-
-size_t Convert::fromShortArray(PVScalarArrayPtr &pv, size_t offset, size_t length,
-    const ShortArray & from, size_t fromOffset)
-{
-    return convertFromShortArray(pv.get(), offset, length, get(from), fromOffset);
-}
-
-size_t Convert::fromIntArray(PVScalarArrayPtr &pv, size_t offset, size_t length,
-    const int32 from[], size_t fromOffset)
-{
-    return convertFromIntArray(pv.get(), offset, length, from, fromOffset);
-}
-
-size_t Convert::fromIntArray(PVScalarArrayPtr &pv, size_t offset, size_t length,
-    const IntArray & from, size_t fromOffset)
-{
-    return convertFromIntArray(pv.get(), offset, length, get(from), fromOffset);
-}
-
-size_t Convert::fromLongArray(PVScalarArrayPtr &pv, size_t offset, size_t length,
-    const int64 from[], size_t fromOffset)
-{
-    return convertFromLongArray(pv.get(), offset, length, from, fromOffset);
-}
-
-size_t Convert::fromLongArray(PVScalarArrayPtr &pv, size_t offset, size_t length,
-    const LongArray & from, size_t fromOffset)
-{
-    return convertFromLongArray(pv.get(), offset, length, get(from), fromOffset);
-}
-
-size_t Convert::fromUByteArray(PVScalarArrayPtr &pv, size_t offset, size_t length,
-    const uint8 from[], size_t fromOffset)
-{
-    return convertFromUByteArray(pv.get(), offset, length, from, fromOffset);
-}
-
-size_t Convert::fromUByteArray(PVScalarArrayPtr &pv, size_t offset, size_t length,
-    const UByteArray & from, size_t fromOffset)
-{
-    return convertFromUByteArray(pv.get(), offset, length, get(from), fromOffset);
-}
-
-size_t Convert::fromUShortArray(PVScalarArrayPtr &pv, size_t offset, size_t length,
-    const uint16 from[], size_t fromOffset)
-{
-    return convertFromUShortArray(pv.get(), offset, length, from, fromOffset);
-}
-
-size_t Convert::fromUShortArray(PVScalarArrayPtr &pv, size_t offset, size_t length,
-    const UShortArray &from, size_t fromOffset)
-{
-    return convertFromUShortArray(pv.get(), offset, length, get(from), fromOffset);
-}
-
-size_t Convert::fromUIntArray(PVScalarArrayPtr &pv, size_t offset, size_t length,
-    const uint32 from[], size_t fromOffset)
-{
-    return convertFromUIntArray(pv.get(), offset, length, from, fromOffset);
-}
-
-size_t Convert::fromUIntArray(PVScalarArrayPtr &pv, size_t offset, size_t length,
-    const UIntArray & from, size_t fromOffset)
-{
-    return convertFromUIntArray(pv.get(), offset, length, get(from), fromOffset);
-}
-
-size_t Convert::fromULongArray(PVScalarArrayPtr &pv, size_t offset, size_t length,
-    const uint64 from[], size_t fromOffset)
-{
-    return convertFromULongArray(pv.get(), offset, length, from, fromOffset);
-}
-
-size_t Convert::fromULongArray(PVScalarArrayPtr &pv, size_t offset, size_t length,
-    const ULongArray &from, size_t fromOffset)
-{
-    return convertFromULongArray(pv.get(), offset, length, get(from), fromOffset);
-}
-
-size_t Convert::fromFloatArray(PVScalarArrayPtr &pv, size_t offset, size_t length,
-    const float from[], size_t fromOffset)
-{
-    return convertFromFloatArray(pv.get(), offset, length, from, fromOffset);
-}
-
-size_t Convert::fromFloatArray(PVScalarArrayPtr &pv, size_t offset, size_t length,
-    const FloatArray & from, size_t fromOffset)
-{
-    return convertFromFloatArray(pv.get(), offset, length, get(from), fromOffset);
-}
-
-size_t Convert::fromDoubleArray(PVScalarArrayPtr &pv, size_t offset, size_t length,
-    const double from[], size_t fromOffset)
-{
-    return convertFromDoubleArray(pv.get(), offset, length, from, fromOffset);
-}
-
-size_t Convert::fromDoubleArray(PVScalarArrayPtr &pv, size_t offset, size_t length,
-    const DoubleArray & from, size_t fromOffset)
-{
-    return convertFromDoubleArray(pv.get(), offset, length, get(from), fromOffset);
-}
-
 void Convert::newLine(StringBuilder buffer, int indentLevel)
 {
-    newLineImpl(buffer,indentLevel);
-}
-
-template<typename PVT,typename T>
-size_t convertFromScalarArray(PVScalarArray *pv,
-    size_t offset, size_t len,const T from[], size_t fromOffset)
-{
-    ScalarType elemType = pv->getScalarArray()->getElementType();
-    size_t ntransfered = 0;
-    String xx = typeid(PVT).name();
-    String yy = typeid(T).name();
-    if(xx.compare(yy)== 0) {
-        PVT *pvdata = static_cast<PVT*>(pv);
-        while (len > 0) {
-            size_t n = pvdata->put(offset, len, from, fromOffset);
-            if (n == 0)
-                break;
-            len -= n;
-            offset += n;
-            fromOffset += n;
-            ntransfered += n;
-        }
-        return ntransfered;
-    }
-    switch (elemType) {
-    case pvBoolean: {
-         String message("convert from numeric array to BooleanArray not legal");
-         throw std::invalid_argument(message);
-    }
-    case pvByte: {
-        PVByteArray *pvdata = static_cast<PVByteArray*>(pv);
-        int8 data[1];
-        while (len > 0) {
-            data[0] = static_cast<int8>(from[fromOffset]);
-            if (pvdata->put(offset, 1, data, 0) == 0)
-                return ntransfered;
-            --len;
-            ++ntransfered;
-            ++offset;
-            ++fromOffset;
-        }
-        return ntransfered;
-    }
-    case pvShort: {
-        PVShortArray *pvdata = static_cast<PVShortArray*>(pv);
-        int16 data[1];
-        while (len > 0) {
-            data[0] = static_cast<int16>(from[fromOffset]);
-            if (pvdata->put(offset, 1, data, 0) == 0)
-                return ntransfered;
-            --len;
-            ++ntransfered;
-            ++offset;
-            ++fromOffset;
-        }
-        return ntransfered;
-    }
-    case pvInt: {
-        PVIntArray *pvdata = static_cast<PVIntArray*>(pv);
-        int32 data[1];
-        while (len > 0) {
-            data[0] = static_cast<int32>(from[fromOffset]);
-            if (pvdata->put(offset, 1, data, 0) == 0)
-                return ntransfered;
-            --len;
-            ++ntransfered;
-            ++offset;
-            ++fromOffset;
-        }
-        return ntransfered;
-    }
-    case pvLong: {
-        PVLongArray *pvdata = static_cast<PVLongArray*>(pv);
-        int64 data[1];
-        while (len > 0) {
-            data[0] = static_cast<int64>(from[fromOffset]);
-            if (pvdata->put(offset, 1, data, 0) == 0)
-                return ntransfered;
-            --len;
-            ++ntransfered;
-            ++offset;
-            ++fromOffset;
-        }
-        return ntransfered;
-    }
-    case pvUByte: {
-        PVUByteArray *pvdata = static_cast<PVUByteArray*>(pv);
-        uint8 data[1];
-        while (len > 0) {
-            data[0] = static_cast<uint8>(from[fromOffset]);
-            if (pvdata->put(offset, 1, data, 0) == 0)
-                return ntransfered;
-            --len;
-            ++ntransfered;
-            ++offset;
-            ++fromOffset;
-        }
-        return ntransfered;
-    }
-    case pvUShort: {
-        PVUShortArray *pvdata = static_cast<PVUShortArray*>(pv);
-        uint16 data[1];
-        while (len > 0) {
-            data[0] = static_cast<uint16>(from[fromOffset]);
-            if (pvdata->put(offset, 1, data, 0) == 0)
-                return ntransfered;
-            --len;
-            ++ntransfered;
-            ++offset;
-            ++fromOffset;
-        }
-        return ntransfered;
-    }
-    case pvUInt: {
-        PVUIntArray *pvdata = static_cast<PVUIntArray*>(pv);
-        uint32 data[1];
-        while (len > 0) {
-            data[0] = static_cast<uint32>(from[fromOffset]);
-            if (pvdata->put(offset, 1, data, 0) == 0)
-                return ntransfered;
-            --len;
-            ++ntransfered;
-            ++offset;
-            ++fromOffset;
-        }
-        return ntransfered;
-    }
-    case pvULong: {
-        PVULongArray *pvdata = static_cast<PVULongArray*>(pv);
-        uint64 data[1];
-        while (len > 0) {
-            data[0] = static_cast<uint64>(from[fromOffset]);
-            if (pvdata->put(offset, 1, data, 0) == 0)
-                return ntransfered;
-            --len;
-            ++ntransfered;
-            ++offset;
-            ++fromOffset;
-        }
-        return ntransfered;
-    }
-    case pvFloat: {
-        PVFloatArray *pvdata = static_cast<PVFloatArray*>(pv);
-        float data[1];
-        while (len > 0) {
-            data[0] = static_cast<float>(from[fromOffset]);
-            if (pvdata->put(offset, 1, data, 0) == 0)
-                return ntransfered;
-            --len;
-            ++ntransfered;
-            ++offset;
-            ++fromOffset;
-        }
-        return ntransfered;
-    }
-    case pvDouble: {
-        PVDoubleArray *pvdata = static_cast<PVDoubleArray*>(pv);
-        double data[1];
-        while (len > 0) {
-            data[0] = static_cast<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);
-}
-
-template<typename T>
-size_t convertToScalarArray(PVScalarArray *pv,
-    size_t offset, size_t len,T to[], size_t toOffset)
-{
-    ScalarType elemType = pv->getScalarArray()->getElementType();
-    size_t ntransfered = 0;
-    switch (elemType) {
-    case pvBoolean: {
-        String message("convert BooleanArray to byte[]] not legal");
-        throw std::invalid_argument(message);
-    }
-    case pvByte: {
-        PVByteArray *pvdata = static_cast<PVByteArray*>(pv);
-        ByteArrayData data;
-        while (len > 0) {
-            size_t num = 0;
-            num = pvdata->get(offset,len,data);
-            if (num <= 0) break;
-            ByteArray & dataArray = data.data;
-            size_t dataOffset = data.offset;
-            for(size_t 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 = static_cast<PVShortArray*>(pv);
-        ShortArrayData data;
-        while (len > 0) {
-            size_t num = pvdata->get(offset, len, data);
-            if (num == 0) break;
-            ShortArray & dataArray = data.data;
-            size_t dataOffset = data.offset;
-            for (size_t i = 0; i < num; i++)
-                to[i + toOffset] =  dataArray[i + dataOffset];
-            len -= num;
-            offset += num;
-            toOffset += num;
-            ntransfered += num;
-        }
-        return ntransfered;
-    }
-    case pvInt: {
-        PVIntArray *pvdata = static_cast<PVIntArray*>(pv);
-        IntArrayData data;
-        while (len > 0) {
-            size_t num = pvdata->get(offset, len, data);
-            if (num == 0) break;
-            IntArray & dataArray = data.data;
-            size_t dataOffset = data.offset;
-            for (size_t i = 0; i < num; i++)
-                to[i + toOffset] =  dataArray[i + dataOffset];
-            len -= num;
-            offset += num;
-            toOffset += num;
-            ntransfered += num;
-        }
-        return ntransfered;
-    }
-    case pvLong: {
-        PVLongArray *pvdata = static_cast<PVLongArray*>(pv);
-        LongArrayData data;
-        while (len > 0) {
-            size_t num = pvdata->get(offset, len, data);
-            if (num == 0)
-                break;
-            LongArray & dataArray = data.data;
-            size_t dataOffset = data.offset;
-            for (size_t i = 0; i < num; i++)
-                to[i + toOffset] = dataArray[i + dataOffset];
-            len -= num;
-            offset += num;
-            toOffset += num;
-            ntransfered += num;
-        }
-        return ntransfered;
-    }
-    case pvUByte: {
-        PVUByteArray *pvdata = static_cast<PVUByteArray*>(pv);
-        UByteArrayData data;
-        while (len > 0) {
-            size_t num = 0;
-            num = pvdata->get(offset,len,data);
-            if (num <= 0) break;
-            UByteArray & dataArray = data.data;
-            size_t dataOffset = data.offset;
-            for(size_t i=0;i<num;i++) to[toOffset+i] = dataArray[dataOffset+1];
-            len -= num;
-            offset += num;
-            toOffset += num;
-            ntransfered += num;
-        }
-        return ntransfered;
-    }
-    case pvUShort: {
-        PVUShortArray *pvdata = static_cast<PVUShortArray*>(pv);
-        UShortArrayData data;
-        while (len > 0) {
-            size_t num = pvdata->get(offset, len, data);
-            if (num == 0) break;
-            UShortArray & dataArray = data.data;
-            size_t dataOffset = data.offset;
-            for (size_t i = 0; i < num; i++)
-                to[i + toOffset] =  dataArray[i + dataOffset];
-            len -= num;
-            offset += num;
-            toOffset += num;
-            ntransfered += num;
-        }
-        return ntransfered;
-    }
-    case pvUInt: {
-        PVUIntArray *pvdata = static_cast<PVUIntArray*>(pv);
-        UIntArrayData data;
-        while (len > 0) {
-            size_t num = pvdata->get(offset, len, data);
-            if (num == 0) break;
-            UIntArray & dataArray = data.data;
-            size_t dataOffset = data.offset;
-            for (size_t i = 0; i < num; i++)
-                to[i + toOffset] =  dataArray[i + dataOffset];
-            len -= num;
-            offset += num;
-            toOffset += num;
-            ntransfered += num;
-        }
-        return ntransfered;
-    }
-    case pvULong: {
-        PVULongArray *pvdata = static_cast<PVULongArray*>(pv);
-        ULongArrayData data;
-        while (len > 0) {
-            size_t num = pvdata->get(offset, len, data);
-            if (num == 0)
-                break;
-            ULongArray & dataArray = data.data;
-            size_t dataOffset = data.offset;
-            for (size_t i = 0; i < num; i++)
-                to[i + toOffset] = dataArray[i + dataOffset];
-            len -= num;
-            offset += num;
-            toOffset += num;
-            ntransfered += num;
-        }
-        return ntransfered;
-    }
-    case pvFloat: {
-        PVFloatArray *pvdata = static_cast<PVFloatArray*>(pv);
-        FloatArrayData data;
-        while (len > 0) {
-            size_t num = pvdata->get(offset, len, data);
-            if (num == 0) break;
-            FloatArray & dataArray = data.data;
-            size_t dataOffset = data.offset;
-            for (size_t i = 0; i < num; i++)
-                to[i + toOffset] = static_cast<T>(dataArray[i + dataOffset]);
-            len -= num;
-            offset += num;
-            toOffset += num;
-            ntransfered += num;
-        }
-        return ntransfered;
-    }
-    case pvDouble: {
-        PVDoubleArray *pvdata = static_cast<PVDoubleArray*>(pv);
-        DoubleArrayData data;
-        while (len > 0) {
-            size_t num = pvdata->get(offset, len, data);
-            if (num == 0)
-                break;
-            DoubleArray & dataArray = data.data;
-            size_t dataOffset = data.offset;
-            for (size_t i = 0; i < num; i++)
-                to[i + toOffset] = static_cast<T>(dataArray[i + dataOffset]);
-            len -= num;
-            offset += num;
-            toOffset += num;
-            ntransfered += num;
-        }
-        return ntransfered;
-    }
-    case pvString: {
-        String message("convert StringArray to numeric not legal");
-        throw std::invalid_argument(message);
-    }
-    }
-     String message("Convert::convertToScalarArray should never get here");
-    throw std::logic_error(message);
-}
-
-size_t convertFromByteArray(PVScalarArray *pv,
-    size_t offset, size_t len,const int8 from[], size_t fromOffset)
-{
-    return convertFromScalarArray<PVByteArray,int8>(pv,offset,len,from,fromOffset);
-}
-
-size_t convertToByteArray(PVScalarArray * pv,
-    size_t offset, size_t len,int8 to[], size_t toOffset)
-{
-    return convertToScalarArray<int8>(pv,offset,len,to,toOffset);
-}
-
-size_t convertFromShortArray(PVScalarArray *pv,
-    size_t offset, size_t len,const int16 from[], size_t fromOffset)
-{
-    return convertFromScalarArray<PVShortArray,int16>(pv,offset,len,from,fromOffset);
-}
-
-size_t convertToShortArray(PVScalarArray * pv,
-    size_t offset, size_t len,int16 to[], size_t toOffset)
-{
-    return convertToScalarArray<int16>(pv,offset,len,to,toOffset);
-}
-
-size_t convertFromIntArray(PVScalarArray *pv,
-    size_t offset, size_t len,const int32 from[], size_t fromOffset)
-{
-    return convertFromScalarArray<PVIntArray,int32>(pv,offset,len,from,fromOffset);
-}
-
-size_t convertToIntArray(PVScalarArray * pv,
-    size_t offset, size_t len,int32 to[], size_t toOffset)
-{
-    return convertToScalarArray<int32>(pv,offset,len,to,toOffset);
-}
-
-size_t convertFromLongArray(PVScalarArray *pv,
-    size_t offset, size_t len,const int64 from[], size_t fromOffset)
-{
-    return convertFromScalarArray<PVLongArray,int64>(pv,offset,len,from,fromOffset);
-}
-
-size_t convertToLongArray(PVScalarArray * pv,
-    size_t offset, size_t len,int64 to[], size_t toOffset)
-{
-    return convertToScalarArray<int64>(pv,offset,len,to,toOffset);
-}
-
-size_t convertFromUByteArray(PVScalarArray *pv,
-    size_t offset, size_t len,const uint8 from[], size_t fromOffset)
-{
-    return convertFromScalarArray<PVUByteArray,uint8>(pv,offset,len,from,fromOffset);
-}
-
-size_t convertToUByteArray(PVScalarArray * pv,
-    size_t offset, size_t len,uint8 to[], size_t toOffset)
-{
-    return convertToScalarArray<uint8>(pv,offset,len,to,toOffset);
-}
-
-size_t convertFromUShortArray(PVScalarArray *pv,
-    size_t offset, size_t len,const uint16 from[], size_t fromOffset)
-{
-    return convertFromScalarArray<PVUShortArray,uint16>(pv,offset,len,from,fromOffset);
-}
-
-size_t convertToUShortArray(PVScalarArray * pv,
-    size_t offset, size_t len,uint16 to[], size_t toOffset)
-{
-    return convertToScalarArray<uint16>(pv,offset,len,to,toOffset);
-}
-
-size_t convertFromUIntArray(PVScalarArray *pv,
-    size_t offset, size_t len,const uint32 from[], size_t fromOffset)
-{
-    return convertFromScalarArray<PVUIntArray,uint32>(pv,offset,len,from,fromOffset);
-}
-
-size_t convertToUIntArray(PVScalarArray * pv,
-    size_t offset, size_t len,uint32 to[], size_t toOffset)
-{
-    return convertToScalarArray<uint32>(pv,offset,len,to,toOffset);
-}
-
-size_t convertFromULongArray(PVScalarArray *pv,
-    size_t offset, size_t len,const uint64 from[], size_t fromOffset)
-{
-    return convertFromScalarArray<PVULongArray,uint64>(pv,offset,len,from,fromOffset);
-}
-
-size_t convertToULongArray(PVScalarArray * pv,
-    size_t offset, size_t len,uint64 to[], size_t toOffset)
-{
-    return convertToScalarArray<uint64>(pv,offset,len,to,toOffset);
-}
-
-size_t convertFromFloatArray(PVScalarArray *pv,
-    size_t offset, size_t len,const float from[], size_t fromOffset)
-{
-    return convertFromScalarArray<PVFloatArray,float>(pv,offset,len,from,fromOffset);
-}
-
-size_t convertToFloatArray(PVScalarArray * pv,
-    size_t offset, size_t len,float to[], size_t toOffset)
-{
-    return convertToScalarArray<float>(pv,offset,len,to,toOffset);
-}
-
-size_t convertFromDoubleArray(PVScalarArray *pv,
-    size_t offset, size_t len,const double from[], size_t fromOffset)
-{
-    return convertFromScalarArray<PVDoubleArray,double>(pv,offset,len,from,fromOffset);
-}
-
-size_t convertToDoubleArray(PVScalarArray * pv,
-    size_t offset, size_t len,double to[], size_t toOffset)
-{
-    return convertToScalarArray<double>(pv,offset,len,to,toOffset);
+    *buffer += "\n";
+    *buffer += String(indentLevel*4, ' ');
 }
 
 ConvertPtr Convert::getConvert()
diff --git a/pvDataApp/pv/convert.h b/pvDataApp/pv/convert.h
index 14532f4..4afa9e5 100644
--- a/pvDataApp/pv/convert.h
+++ b/pvDataApp/pv/convert.h
@@ -446,11 +446,13 @@ public:
      * @return number of elements converted
      * @throws std::invalid_argument if the element type is not numeric
      */
+    inline
     std::size_t toByteArray(PVScalarArrayPtr const & pv,
         std::size_t offset,
         std::size_t length,
         int8* to,
-        std::size_t toOffset);
+        std::size_t toOffset)
+    { pv->getAs<pvByte>(to+toOffset, length, offset); return length; }
     /**
      * Convert a PV array to a short array.
      * @param pv a PV
@@ -461,11 +463,13 @@ public:
      * @return number of elements converted
     * @throws std::invalid_argument if the element type is not numeric
     */
+    inline
     std::size_t toShortArray(PVScalarArrayPtr const & pv,
         std::size_t offset,
         std::size_t length,
         int16* to,
-        std::size_t toOffset);
+        std::size_t toOffset)
+    { pv->getAs<pvShort>(to+toOffset, length, offset); return length; }
     /**
      * Convert a PV array to an int array.
      * @param pv a PV
@@ -476,11 +480,13 @@ public:
      * @return number of elements converted
      * @throws std::invalid_argument if the element type is not numeric
      */
+    inline
     std::size_t toIntArray(PVScalarArrayPtr const & pv,
         std::size_t offset,
         std::size_t length,
         int32* to,
-        std::size_t toOffset);
+        std::size_t toOffset)
+    { pv->getAs<pvInt>(to+toOffset, length, offset); return length; }
     /**
      * Convert a PV array to a long array.
      * @param pv a PV
@@ -491,11 +497,13 @@ public:
      * @return number of elements converted
      * @throws std::invalid_argument if the element type is not numeric
      */
+    inline
     std::size_t toLongArray(PVScalarArrayPtr const & pv,
         std::size_t offset,
         std::size_t length,
         int64* to,
-        std::size_t toOffset);
+        std::size_t toOffset)
+    { pv->getAs<pvLong>(to+toOffset, length, offset); return length; }
     /**
      * Convert a PV array to a ubyte array.
      * @param pv a PV
@@ -506,11 +514,13 @@ public:
      * @return number of elements converted
      * @throws std::invalid_argument if the element type is not numeric
      */
+    inline
     std::size_t toUByteArray(PVScalarArrayPtr const & pv,
         std::size_t offset,
         std::size_t length,
         uint8* to,
-        std::size_t toOffset);
+        std::size_t toOffset)
+    { pv->getAs<pvUByte>(to+toOffset, length, offset); return length; }
     /**
      * Convert a PV array to a ushort array.
      * @param pv a PV
@@ -521,11 +531,13 @@ public:
      * @return number of elements converted
     * @throws std::invalid_argument if the element type is not numeric
     */
+    inline
     std::size_t toUShortArray(PVScalarArrayPtr const & pv,
         std::size_t offset,
         std::size_t length,
         uint16* to,
-        std::size_t toOffset);
+        std::size_t toOffset)
+    { pv->getAs<pvUShort>(to+toOffset, length, offset); return length; }
     /**
      * Convert a PV array to an uint array.
      * @param pv a PV
@@ -536,12 +548,14 @@ public:
      * @return number of elements converted
      * @throws std::invalid_argument if the element type is not numeric
      */
+    inline
     std::size_t toUIntArray(
         PVScalarArrayPtr const & pv,
         std::size_t offset,
         std::size_t length,
         uint32* to,
-        std::size_t toOffset);
+        std::size_t toOffset)
+    { pv->getAs<pvUInt>(to+toOffset, length, offset); return length; }
     /**
      * Convert a PV array to a ulong array.
      * @param pv a PV
@@ -552,12 +566,14 @@ public:
      * @return number of elements converted
      * @throws std::invalid_argument if the element type is not numeric
      */
+    inline
     std::size_t toULongArray(
         PVScalarArrayPtr const & pv,
         std::size_t offset,
         std::size_t length,
         uint64* to,
-        std::size_t toOffset);
+        std::size_t toOffset)
+    { pv->getAs<pvULong>(to+toOffset, length, offset); return length; }
      /**
       * Convert a PV array to a float array.
       * @param pv a PV
@@ -568,12 +584,14 @@ public:
       * @return number of elements converted
       * @throws std::invalid_argument if the element type is not numeric
       */
+    inline
     std::size_t toFloatArray(
         PVScalarArrayPtr const & pv,
         std::size_t offset,
         std::size_t length,
         float* to,
-        std::size_t toOffset);
+        std::size_t toOffset)
+    { pv->getAs<pvFloat>(to+toOffset, length, offset); return length; }
     /**
      * Convert a PV array to a double array.
      * @param pv a PV
@@ -584,12 +602,14 @@ public:
      * @return number of elements converted
      * @throws std::invalid_argument if the element type is not numeric
      */
+    inline
     std::size_t toDoubleArray(
         PVScalarArrayPtr const & pv,
         std::size_t offset,
         std::size_t length,
         double* to, std::size_t
-        toOffset);
+        toOffset)
+    { pv->getAs<pvDouble>(to+toOffset, length, offset); return length; }
     /**
      * Convert a PV array from a byte array.
      * @param pv a PV
@@ -600,12 +620,16 @@ public:
      * @return number of elements converted
      * @throws std::invalid_argument if the element type is not numeric
      */
+    inline
     std::size_t fromByteArray(
         PVScalarArrayPtr & pv, std::size_t offset, std::size_t length,
-        const int8* from, std::size_t fromOffset);
+        const int8* from, std::size_t fromOffset)
+    { pv->putFrom<pvByte>(from+fromOffset, length, offset); return length; }
+    inline
     std::size_t fromByteArray(
         PVScalarArrayPtr & pv, std::size_t offset, std::size_t length,
-        const ByteArray & from, std::size_t fromOffset);
+        const ByteArray & from, std::size_t fromOffset)
+    {return fromByteArray(pv, offset, length, &from[0], fromOffset);}
     /**
      * Convert a PV array from a short array.
      * @param pv a PV
@@ -616,12 +640,16 @@ public:
      * @return number of elements converted
      * @throws std::invalid_argument if the element type is not numeric
      */
+    inline
     std::size_t fromShortArray(
         PVScalarArrayPtr & pv, std::size_t offset, std::size_t length,
-        const int16* from, std::size_t fromOffset);
+        const int16* from, std::size_t fromOffset)
+    { pv->putFrom<pvShort>(from+fromOffset, length, offset); return length; }
+    inline
     std::size_t fromShortArray(
         PVScalarArrayPtr & pv, std::size_t offset, std::size_t length,
-        const ShortArray & from, std::size_t fromOffset);
+        const ShortArray & from, std::size_t fromOffset)
+    {return fromShortArray(pv, offset, length, &from[0], fromOffset);}
     /**
      * Convert a PV array from an int array.
      * @param pv a PV
@@ -632,12 +660,16 @@ public:
      * @return number of elements converted
      * @throws std::invalid_argument if the element type is not numeric
      */
+    inline
     std::size_t fromIntArray(
        PVScalarArrayPtr & pv, std::size_t offset, std::size_t length,
-       const int32* from, std::size_t fromOffset);
+       const int32* from, std::size_t fromOffset)
+    { pv->putFrom<pvInt>(from+fromOffset, length, offset); return length; }
+    inline
     std::size_t fromIntArray(
        PVScalarArrayPtr & pv, std::size_t offset, std::size_t length,
-       const IntArray & from, std::size_t fromOffset);
+       const IntArray & from, std::size_t fromOffset)
+    {return fromIntArray(pv, offset, length, &from[0], fromOffset);}
     /**
      * Convert a PV array from a long array.
      * @param pv a PV
@@ -648,12 +680,16 @@ public:
      * @return number of elements converted
      * @throws std::invalid_argument if the element type is not numeric
      */
+    inline
     std::size_t fromLongArray(
         PVScalarArrayPtr & pv, std::size_t offset, std::size_t length,
-        const int64* from, std::size_t fromOffset);
+        const int64* from, std::size_t fromOffset)
+    { pv->putFrom<pvLong>(from+fromOffset, length, offset); return length; }
+    inline
     std::size_t fromLongArray(
         PVScalarArrayPtr & pv, std::size_t offset, std::size_t length,
-        const LongArray & from, std::size_t fromOffset);
+        const LongArray & from, std::size_t fromOffset)
+    {return fromLongArray(pv, offset, length, &from[0], fromOffset);}
     /**
      * Convert a PV array from a ubyte array.
      * @param pv a PV
@@ -664,12 +700,16 @@ public:
      * @return number of elements converted
      * @throws std::invalid_argument if the element type is not numeric
      */
+    inline
     std::size_t fromUByteArray(
         PVScalarArrayPtr & pv, std::size_t offset, std::size_t length,
-        const uint8* from, std::size_t fromOffset);
+        const uint8* from, std::size_t fromOffset)
+    { pv->putFrom<pvUByte>(from+fromOffset, length, offset); return length; }
+    inline
     std::size_t fromUByteArray(
         PVScalarArrayPtr & pv, std::size_t offset, std::size_t length,
-        const UByteArray & from, std::size_t fromOffset);
+        const UByteArray & from, std::size_t fromOffset)
+    {return fromUByteArray(pv, offset, length, &from[0], fromOffset);}
     /**
      * Convert a PV array from a ushort array.
      * @param pv a PV
@@ -680,12 +720,16 @@ public:
      * @return number of elements converted
      * @throws std::invalid_argument if the element type is not numeric
      */
+    inline
     std::size_t fromUShortArray(
         PVScalarArrayPtr & pv, std::size_t offset, std::size_t length,
-        const uint16* from, std::size_t fromOffset);
+        const uint16* from, std::size_t fromOffset)
+    { pv->putFrom<pvUShort>(from+fromOffset, length, offset); return length; }
+    inline
     std::size_t fromUShortArray(
         PVScalarArrayPtr & pv, std::size_t offset, std::size_t length,
-        const UShortArray & from, std::size_t fromOffset);
+        const UShortArray & from, std::size_t fromOffset)
+    {return fromUShortArray(pv, offset, length, &from[0], fromOffset);}
     /**
      * Convert a PV array from an uint array.
      * @param pv a PV
@@ -696,12 +740,16 @@ public:
      * @return number of elements converted
      * @throws std::invalid_argument if the element type is not numeric
      */
+    inline
     std::size_t fromUIntArray(
         PVScalarArrayPtr & pv, std::size_t offset, std::size_t length,
-        const uint32* from, std::size_t fromOffset);
+        const uint32* from, std::size_t fromOffset)
+    { pv->putFrom<pvUInt>(from+fromOffset, length, offset); return length; }
+    inline
     std::size_t fromUIntArray(
         PVScalarArrayPtr & pv, std::size_t offset, std::size_t length,
-        const UIntArray & from, std::size_t fromOffset);
+        const UIntArray & from, std::size_t fromOffset)
+    {return fromUIntArray(pv, offset, length, &from[0], fromOffset);}
     /**
      * Convert a PV array from a ulong array.
      * @param pv a PV
@@ -712,12 +760,16 @@ public:
      * @return number of elements converted
      * @throws std::invalid_argument if the element type is not numeric
      */
+    inline
     std::size_t fromULongArray(
         PVScalarArrayPtr & pv, std::size_t offset, std::size_t length,
-        const uint64* from, std::size_t fromOffset);
+        const uint64* from, std::size_t fromOffset)
+    { pv->putFrom<pvULong>(from+fromOffset, length, offset); return length; }
+    inline
     std::size_t fromULongArray(
         PVScalarArrayPtr & pv, std::size_t offset, std::size_t length,
-        const ULongArray & from, std::size_t fromOffset);
+        const ULongArray & from, std::size_t fromOffset)
+    {return fromULongArray(pv, offset, length, &from[0], fromOffset);}
     /**
      * Convert a PV array from a float array.
      * @param pv a PV
@@ -728,12 +780,16 @@ public:
      * @return number of elements converted
      * @throws std::invalid_argument if the element type is not numeric
      */
+    inline
     std::size_t fromFloatArray(
         PVScalarArrayPtr & pv, std::size_t offset, std::size_t length,
-        const float* from, std::size_t fromOffset);
+        const float* from, std::size_t fromOffset)
+    { pv->putFrom<pvFloat>(from+fromOffset, length, offset); return length; }
+    inline
     std::size_t fromFloatArray(
         PVScalarArrayPtr & pv, std::size_t offset, std::size_t length,
-        const FloatArray & from, std::size_t fromOffset);
+        const FloatArray & from, std::size_t fromOffset)
+    {return fromFloatArray(pv, offset, length, &from[0], fromOffset);}
     /**
      * Convert a PV array from a double array.
      * @param pv a PV
@@ -744,12 +800,16 @@ public:
      * @return number of elements converted
      * @throws std::invalid_argument if the element type is not numeric
      */
+    inline
     std::size_t fromDoubleArray(
         PVScalarArrayPtr & pv, std::size_t offset, std::size_t length,
-        const double* from, std::size_t fromOffset);
+        const double* from, std::size_t fromOffset)
+    { pv->putFrom<pvDouble>(from+fromOffset, length, offset); return length; }
+    inline
     std::size_t fromDoubleArray(
         PVScalarArrayPtr & pv, std::size_t offset, std::size_t length,
-        const DoubleArray & from, std::size_t fromOffset);
+        const DoubleArray & from, std::size_t fromOffset)
+    {return fromDoubleArray(pv, offset, length, &from[0], fromOffset);}
     /**
      * Convenience method for implementing toString.
      * It generates a newline and inserts blanks at the beginning of the newline.