diff --git a/pvDataApp/factory/BasePVStructureArray.h b/pvDataApp/factory/BasePVStructureArray.h
index 564a445..c48d876 100644
--- a/pvDataApp/factory/BasePVStructureArray.h
+++ b/pvDataApp/factory/BasePVStructureArray.h
@@ -68,24 +68,6 @@ namespace epics { namespace pvData {
         throw std::logic_error(notImplemented);
     }
 
-    void PVStructureArray::serialize(ByteBuffer *pbuffer,
-        SerializableControl *pflusher) 
-    {
-        throw std::logic_error(notImplemented);
-    }
-
-    void PVStructureArray::deserialize(ByteBuffer *pbuffer,
-        DeserializableControl *pflusher)
-    {
-        throw std::logic_error(notImplemented);
-    }
-
-    void PVStructureArray::serialize(ByteBuffer *pbuffer,
-            SerializableControl *pflusher, int offset, int count) 
-    {
-        throw std::logic_error(notImplemented);
-    }
-
     void PVStructureArray::toString(StringBuilder buf)  {toString(buf,0);}
 
     void PVStructureArray::toString(StringBuilder buf,int indentLevel) 
@@ -93,6 +75,24 @@ namespace epics { namespace pvData {
         throw std::logic_error(notImplemented);
     }
 
+    void PVStructureArray::serialize(
+        ByteBuffer *pbuffer,SerializableControl *pflusher)
+    {
+        throw std::logic_error(notImplemented);
+    }
+
+    void PVStructureArray::deserialize(
+        ByteBuffer *pbuffer,DeserializableControl *pflusher)
+    {
+        throw std::logic_error(notImplemented);
+    }
+
+    void PVStructureArray::serialize(ByteBuffer *pbuffer,
+            SerializableControl *pflusher, int offset, int count)
+    {
+        throw std::logic_error(notImplemented);
+    }
+
     bool PVStructureArray::operator==(PVField  *pv) 
     {
         throw std::logic_error(notImplemented);
@@ -106,11 +106,21 @@ namespace epics { namespace pvData {
     class BasePVStructureArray : public PVStructureArray {
     public:
         BasePVStructureArray(PVStructure *parent,
-             StructureArrayConstPtr structureArray)
-        : PVStructureArray(parent,structureArray) {}
-        ~BasePVStructureArray(){}
+             StructureArrayConstPtr structureArray);
+        ~BasePVStructureArray();
+        virtual void setCapacity(int capacity);
     private:
     };
 
+
+    BasePVStructureArray::BasePVStructureArray(
+        PVStructure *parent,StructureArrayConstPtr structureArray)
+        : PVStructureArray(parent,structureArray) {}
+
+    BasePVStructureArray::~BasePVStructureArray() {}
+
+    void BasePVStructureArray::setCapacity(int capacity) {
+        throw std::logic_error(notImplemented);
+    }
 }}
 #endif  /* BASEPVSTRUCTUREARRAY_H */
diff --git a/pvDataApp/factory/PVAuxInfoImpl.cpp b/pvDataApp/factory/PVAuxInfoImpl.cpp
index 569dcfb..e99d82b 100644
--- a/pvDataApp/factory/PVAuxInfoImpl.cpp
+++ b/pvDataApp/factory/PVAuxInfoImpl.cpp
@@ -47,9 +47,9 @@ namespace epics { namespace pvData {
 
     }
 
-    std::map<String, PVScalar * > *PVAuxInfo::getInfos()
+    PVScalarMap PVAuxInfo::getInfos()
     {
-        return &pImpl->theMap;
+        return pImpl->theMap;
     }
 
     PVScalar * PVAuxInfo::getInfo(String key)
diff --git a/pvDataApp/factory/PVDataCreateFactory.cpp b/pvDataApp/factory/PVDataCreateFactory.cpp
index e7a095f..03629e2 100644
--- a/pvDataApp/factory/PVDataCreateFactory.cpp
+++ b/pvDataApp/factory/PVDataCreateFactory.cpp
@@ -34,169 +34,212 @@
 
 namespace epics { namespace pvData {
 
-   static FieldCreate * fieldCreate = 0;
-   static PVDataCreate* pvDataCreate = 0;
+static Convert* convert = 0;
+static FieldCreate * fieldCreate = 0;
+static PVDataCreate* pvDataCreate = 0;
 
-   PVDataCreate::PVDataCreate(){};
+PVDataCreate::PVDataCreate(){}
 
-   PVField *PVDataCreate::createPVField(PVStructure *parent,
-           FieldConstPtr field)
-   {
-        switch(field->getType()) {
-        case scalar:
-            return createPVScalar(parent,(ScalarConstPtr)field);
-        case scalarArray:
-            return (PVField *)createPVScalarArray(parent,
-                (ScalarArrayConstPtr)field);
-        case structure:
-            return (PVField *)createPVStructure(parent,
-                (StructureConstPtr)field);
-        case structureArray:
-            return createPVStructureArray(parent,
-                (StructureArrayConstPtr)field);
-        }
-        String  message("PVDataCreate::createPVField");
+PVField *PVDataCreate::createPVField(PVStructure *parent,
+        FieldConstPtr field)
+{
+     switch(field->getType()) {
+     case scalar:
+         return createPVScalar(parent,(ScalarConstPtr)field);
+     case scalarArray:
+         return (PVField *)createPVScalarArray(parent,
+             (ScalarArrayConstPtr)field);
+     case structure:
+         return (PVField *)createPVStructure(parent,
+             (StructureConstPtr)field);
+     case structureArray:
+         return createPVStructureArray(parent,
+             (StructureArrayConstPtr)field);
+     }
+     String  message("PVDataCreate::createPVField should never get here");
+     throw std::logic_error(message);
+}
+
+PVField *PVDataCreate::createPVField(PVStructure *parent,
+        String fieldName,PVField * fieldToClone)
+{
+     switch(fieldToClone->getField()->getType()) {
+     case scalar:
+         return createPVScalar(parent,fieldName,(PVScalar*)fieldToClone);
+     case scalarArray:
+         return (PVField *)createPVScalarArray(parent,fieldName,
+             (PVScalarArray *)fieldToClone);
+     case structure:
+         return (PVField *)createPVStructure(parent,fieldName,
+             (PVStructure *)fieldToClone);
+     case structureArray:
+        String message(
+        "PVDataCreate::createPVField structureArray not valid fieldToClone");
         throw std::invalid_argument(message);
-   };
+     }
+     String  message("PVDataCreate::createPVField should never get here");
+     throw std::logic_error(message);
+}
 
-   PVField *PVDataCreate::createPVField(PVStructure *parent,
-           String fieldName,PVField * fieldToClone)
-   {
-        switch(fieldToClone->getField()->getType()) {
-        case scalar:
-            return createPVScalar(parent,fieldName,(PVScalar*)fieldToClone);
-        case scalarArray:
-            return (PVField *)createPVScalarArray(parent,fieldName,
-                (PVScalarArray *)fieldToClone);
-        case structure:
-            return (PVField *)createPVStructure(parent,fieldName,
-                (PVStructure *)fieldToClone);
-        case structureArray:
-           String message(
-           "PVDataCreate::createPVField structureArray not valid fieldToClone");
-           throw std::invalid_argument(message);
-        }
-        String message("PVDataCreate::createPVField");
-        throw std::logic_error(message);
-   };
+PVScalar *PVDataCreate::createPVScalar(PVStructure *parent,ScalarConstPtr scalar)
+{
+     ScalarType scalarType = scalar->getScalarType();
+     switch(scalarType) {
+     case pvBoolean:
+         return new BasePVBoolean(parent,scalar);
+     case pvByte:
+         return new BasePVByte(parent,scalar);
+     case pvShort:
+         return new BasePVShort(parent,scalar);
+     case pvInt:
+         return new BasePVInt(parent,scalar);
+     case pvLong:
+         return new BasePVLong(parent,scalar);
+     case pvFloat:
+         return new BasePVFloat(parent,scalar);
+     case pvDouble:
+         return new BasePVDouble(parent,scalar);
+     case pvString:
+         return new BasePVString(parent,scalar);
+     }
+     String  message("PVDataCreate::createPVScalar should never get here");
+     throw std::logic_error(message);
+}
 
-   PVScalar *PVDataCreate::createPVScalar(PVStructure *parent,ScalarConstPtr scalar)
-   {
-        ScalarType scalarType = scalar->getScalarType();
-        switch(scalarType) {
-        case pvBoolean:
-            return new BasePVBoolean(parent,scalar);
-        case pvByte:
-            return new BasePVByte(parent,scalar);
-        case pvShort:
-            return new BasePVShort(parent,scalar);
-        case pvInt:
-            return new BasePVInt(parent,scalar);
-        case pvLong:
-            return new BasePVLong(parent,scalar);
-        case pvFloat:
-            return new BasePVFloat(parent,scalar);
-        case pvDouble:
-            return new BasePVDouble(parent,scalar);
-        case pvString:
-            return new BasePVString(parent,scalar);
-        default:
-            throw std::logic_error(notImplemented);
-        }
-        throw std::logic_error(notImplemented);
-   };
-
-   PVScalar *PVDataCreate::createPVScalar(PVStructure *parent,
-           String fieldName,ScalarType scalarType)
-   {
-        if(fieldCreate==0) fieldCreate = getFieldCreate();
-        ScalarConstPtr scalar = fieldCreate->createScalar(fieldName,scalarType);
-        return createPVScalar(parent,scalar);
-   };
-
-   PVScalar *PVDataCreate::createPVScalar(PVStructure *parent,
-           String fieldName,PVScalar * scalarToClone)
-   {
-        PVScalar *pvScalar = createPVScalar(parent,fieldName,
-            scalarToClone->getScalar()->getScalarType());
-        //MARTY MUST CALL CONVERT
-        //MARTY MUST COPY AUXInfo
-        return pvScalar;
-   };
-
-   PVScalarArray *PVDataCreate::createPVScalarArray(PVStructure *parent,
-           ScalarArrayConstPtr scalarArray)
-   {
-        switch(scalarArray->getElementType()) {
-        case pvBoolean:
-              return new BasePVBooleanArray(parent,scalarArray);
-        case pvByte:
-              return new BasePVByteArray(parent,scalarArray);
-        case pvShort:
-              return new BasePVShortArray(parent,scalarArray);
-        case pvInt:
-              return new BasePVIntArray(parent,scalarArray);
-        case pvLong:
-              return new BasePVLongArray(parent,scalarArray);
-        case pvFloat:
-              return new BasePVFloatArray(parent,scalarArray);
-        case pvDouble:
-              return new BasePVDoubleArray(parent,scalarArray);
-        case pvString:
-              return new BasePVStringArray(parent,scalarArray);
-        }
-        throw std::logic_error(notImplemented);
-        
-   };
-
-   PVScalarArray *PVDataCreate::createPVScalarArray(PVStructure *parent,
-           String fieldName,ScalarType elementType)
-   {
-        throw std::logic_error(notImplemented);
-   };
-
-   PVScalarArray *PVDataCreate::createPVScalarArray(PVStructure *parent,
-           String fieldName,PVScalarArray * scalarArrayToClone)
-   {
-        throw std::logic_error(notImplemented);
-   };
-
-   PVStructureArray *PVDataCreate::createPVStructureArray(PVStructure *parent,
-           StructureArrayConstPtr structureArray)
-   {
-        throw std::logic_error(notImplemented);
-   };
-
-   PVStructure *PVDataCreate::createPVStructure(PVStructure *parent,
-           StructureConstPtr structure)
-   {
-        return new BasePVStructure(parent,structure);
-   };
-
-   PVStructure *PVDataCreate::createPVStructure(PVStructure *parent,
-           String fieldName,FieldConstPtrArray fields)
-   {
-        throw std::logic_error(notImplemented);
-   };
-
-   PVStructure *PVDataCreate::createPVStructure(PVStructure *parent,
-           String fieldName,PVStructure *structToClone)
-   {
-        throw std::logic_error(notImplemented);
-   };
+PVScalar *PVDataCreate::createPVScalar(PVStructure *parent,
+        String fieldName,ScalarType scalarType)
+{
+     if(fieldCreate==0) fieldCreate = getFieldCreate();
+     ScalarConstPtr scalar = fieldCreate->createScalar(fieldName,scalarType);
+     return createPVScalar(parent,scalar);
+}
 
 
-   class PVDataCreateExt : public PVDataCreate {
-   public:
-       PVDataCreateExt(): PVDataCreate(){};
-   };
+PVScalar *PVDataCreate::createPVScalar(PVStructure *parent,
+        String fieldName,PVScalar * scalarToClone)
+{
+     if(convert==0) convert = getConvert();
+     PVScalar *pvScalar = createPVScalar(parent,fieldName,
+         scalarToClone->getScalar()->getScalarType());
+     convert->copyScalar(scalarToClone, pvScalar);
+     PVScalarMap attributes = scalarToClone->getPVAuxInfo()->getInfos();
+     PVAuxInfo *pvAttribute = pvScalar->getPVAuxInfo();
+     PVScalarMapIter p;
+     for(p=attributes.begin(); p!=attributes.end(); p++) {
+          String key = p->first;
+          PVScalar *fromAttribute = p->second;
+          PVScalar *toAttribute = pvAttribute->createInfo(key,
+              fromAttribute->getScalar()->getScalarType());
+          convert->copyScalar(fromAttribute,toAttribute);
+     }
+     return pvScalar;
+}
 
-    PVDataCreate * getPVDataCreate() {
-        static Mutex mutex = Mutex();
-        Lock xx(&mutex);
+PVScalarArray *PVDataCreate::createPVScalarArray(PVStructure *parent,
+        ScalarArrayConstPtr scalarArray)
+{
+     switch(scalarArray->getElementType()) {
+     case pvBoolean:
+           return new BasePVBooleanArray(parent,scalarArray);
+     case pvByte:
+           return new BasePVByteArray(parent,scalarArray);
+     case pvShort:
+           return new BasePVShortArray(parent,scalarArray);
+     case pvInt:
+           return new BasePVIntArray(parent,scalarArray);
+     case pvLong:
+           return new BasePVLongArray(parent,scalarArray);
+     case pvFloat:
+           return new BasePVFloatArray(parent,scalarArray);
+     case pvDouble:
+           return new BasePVDoubleArray(parent,scalarArray);
+     case pvString:
+           return new BasePVStringArray(parent,scalarArray);
+     }
+     throw std::logic_error(notImplemented);
+     
+}
 
-        if(pvDataCreate==0) pvDataCreate = new PVDataCreateExt();
-        return pvDataCreate;
+PVScalarArray *PVDataCreate::createPVScalarArray(PVStructure *parent,
+        String fieldName,ScalarType elementType)
+{
+     if(fieldCreate==0) fieldCreate = getFieldCreate();
+     return createPVScalarArray(parent,
+         fieldCreate->createScalarArray(fieldName, elementType));
+}
+
+PVScalarArray *PVDataCreate::createPVScalarArray(PVStructure *parent,
+        String fieldName,PVScalarArray * arrayToClone)
+{
+     if(convert==0) convert = getConvert();
+     PVScalarArray *pvArray = createPVScalarArray(parent,fieldName,
+          arrayToClone->getScalarArray()->getElementType());
+     convert->copyScalarArray(arrayToClone,0, pvArray,0,arrayToClone->getLength());
+     PVScalarMap attributes = arrayToClone->getPVAuxInfo()->getInfos();
+     PVAuxInfo *pvAttribute = pvArray->getPVAuxInfo();
+     PVScalarMapIter p;
+     for(p=attributes.begin(); p!=attributes.end(); p++) {
+          String key = p->first;
+          PVScalar *fromAttribute = p->second;
+          PVScalar *toAttribute = pvAttribute->createInfo(key,
+              fromAttribute->getScalar()->getScalarType());
+          convert->copyScalar(fromAttribute,toAttribute);
+     }
+    return pvArray;
+}
+
+PVStructureArray *PVDataCreate::createPVStructureArray(PVStructure *parent,
+        StructureArrayConstPtr structureArray)
+{
+     return new BasePVStructureArray(parent,structureArray);
+}
+
+PVStructure *PVDataCreate::createPVStructure(PVStructure *parent,
+        StructureConstPtr structure)
+{
+     return new BasePVStructure(parent,structure);
+}
+
+PVStructure *PVDataCreate::createPVStructure(PVStructure *parent,
+        String fieldName,int numberFields,FieldConstPtrArray fields)
+{
+     if(fieldCreate==0) fieldCreate = getFieldCreate();
+     StructureConstPtr structure = fieldCreate->createStructure(
+         fieldName,numberFields, fields);
+     return new BasePVStructure(parent,structure);
+}
+
+PVStructure *PVDataCreate::createPVStructure(PVStructure *parent,
+        String fieldName,PVStructure *structToClone)
+{
+    if(fieldCreate==0) fieldCreate = getFieldCreate();
+    if(convert==0) convert = getConvert();
+    FieldConstPtrArray fields = 0;
+    int numberFields = 0;
+    if(structToClone==0) {
+        fields = new FieldConstPtr[0];
+    } else {
+        fields = structToClone->getStructure()->getFields();
+        numberFields = structToClone->getStructure()->getNumberFields();
     }
+    StructureConstPtr structure = fieldCreate->createStructure(fieldName,numberFields,fields);
+    PVStructure *pvStructure = new BasePVStructure(parent,structure);
+    if(structToClone!=0) convert->copyStructure(structToClone,pvStructure);
+    return pvStructure;
+}
+
+
+class PVDataCreateExt : public PVDataCreate {
+public:
+    PVDataCreateExt(): PVDataCreate(){}
+};
+
+ PVDataCreate * getPVDataCreate() {
+     static Mutex mutex = Mutex();
+     Lock xx(&mutex);
+
+     if(pvDataCreate==0) pvDataCreate = new PVDataCreateExt();
+     return pvDataCreate;
+ }
 
 }}
diff --git a/pvDataApp/pv/pvData.h b/pvDataApp/pv/pvData.h
index 84200c3..e17e4fd 100644
--- a/pvDataApp/pv/pvData.h
+++ b/pvDataApp/pv/pvData.h
@@ -38,15 +38,17 @@ namespace epics { namespace pvData {
     class PVStructure;
     class PVStructureArray;
 
-    // NOTE this prevents compiler from generating default methods for this and 
-    // derived classes
+
+    typedef std::map<String,PVScalar * > PVScalarMap;
+    typedef PVScalarMap::const_iterator PVScalarMapIter;
+
     class PVAuxInfo : private NoDefaultMethods {
     public:
         PVAuxInfo(PVField *pvField);
         ~PVAuxInfo();
         PVField * getPVField();
         PVScalar * createInfo(String key,ScalarType scalarType);
-        std::map<String, PVScalar * > *getInfos();
+        PVScalarMap getInfos();
         PVScalar * getInfo(String key);
         void toString(StringBuilder buf);
         void toString(StringBuilder buf,int indentLevel);
@@ -155,22 +157,22 @@ namespace epics { namespace pvData {
     class PVStructureArray : public PVArray {
     public:
         virtual ~PVStructureArray();
-        virtual StructureArrayConstPtr getStructureArray() = 0;
+        virtual StructureArrayConstPtr getStructureArray();
         virtual int get(int offset, int length,
-            StructureArrayData *data) = 0;
+            StructureArrayData *data);
         virtual int put(int offset,int length,
-            PVStructurePtrArray from, int fromOffset) = 0;
-        virtual void shareData( PVStructurePtrArray value,int capacity,int length) = 0;
+            PVStructurePtrArray from, int fromOffset);
+        virtual void shareData( PVStructurePtrArray value,int capacity,int length);
         virtual void serialize(ByteBuffer *pbuffer,
-            SerializableControl *pflusher) = 0 ;
+            SerializableControl *pflusher) ;
         virtual void deserialize(ByteBuffer *buffer,
-            DeserializableControl *pflusher) = 0;
+            DeserializableControl *pflusher);
         virtual void serialize(ByteBuffer *pbuffer,
-            SerializableControl *pflusher, int offset, int count) = 0;
-        virtual void toString(StringBuilder buf) = 0;
-        virtual void toString(StringBuilder buf,int indentLevel) = 0;
-        virtual bool operator==(PVField *pv) = 0;
-        virtual bool operator!=(PVField *pv) = 0;
+            SerializableControl *pflusher, int offset, int count);
+        virtual void toString(StringBuilder buf);
+        virtual void toString(StringBuilder buf,int indentLevel);
+        virtual bool operator==(PVField *pv);
+        virtual bool operator!=(PVField *pv);
     protected:
         PVStructureArray(PVStructure *parent,
             StructureArrayConstPtr structureArray);
@@ -521,7 +523,7 @@ namespace epics { namespace pvData {
        PVStructure *createPVStructure(PVStructure *parent,
            StructureConstPtr structure);
        PVStructure *createPVStructure(PVStructure *parent,
-           String fieldName,FieldConstPtrArray fields);
+           String fieldName,int numberFields,FieldConstPtrArray fields);
        PVStructure *createPVStructure(PVStructure *parent,
            String fieldName,PVStructure *structToClone);
     protected:
diff --git a/pvDataApp/test/Makefile b/pvDataApp/test/Makefile
index cb8c0f7..302435a 100644
--- a/pvDataApp/test/Makefile
+++ b/pvDataApp/test/Makefile
@@ -13,6 +13,7 @@ testPVAuxInfo_LIBS += pvFactory
 PROD_HOST += testPVScalar
 testPVScalar_SRCS += testPVScalar.cpp
 testPVScalar_LIBS += pvFactory
+testPVScalar_LIBS += pvMisc Com
 
 PROD_HOST += testPVScalarArray
 testPVScalarArray_SRCS += testPVScalarArray.cpp
diff --git a/pvDataApp/test/testPVScalar.cpp b/pvDataApp/test/testPVScalar.cpp
index 4e9e1c3..7246e8b 100644
--- a/pvDataApp/test/testPVScalar.cpp
+++ b/pvDataApp/test/testPVScalar.cpp
@@ -6,6 +6,7 @@
 #include <stddef.h>
 #include <string.h>
 #include <stdio.h>
+#include <epicsAssert.h>
 
 #include "requester.h"
 #include "pvIntrospect.h"