diff --git a/pvDataApp/factory/FieldCreateFactory.cpp b/pvDataApp/factory/FieldCreateFactory.cpp
index 802cec5..36f2309 100644
--- a/pvDataApp/factory/FieldCreateFactory.cpp
+++ b/pvDataApp/factory/FieldCreateFactory.cpp
@@ -10,78 +10,28 @@
 
 namespace epics { namespace pvData {
 
-    void TypeFunc::toString(std::string &buf,const Type type) {
-        static const std::string unknownString = "logic error unknown Type";
-        switch(type) {
-        case scalar : buf += "scalar"; break;
-        case scalarArray : buf += "scalarArray"; break;
-        case structure : buf += "structure"; break;
-        case structureArray : buf += "structureArray"; break;
-        default:
-        throw std::invalid_argument(unknownString);
-        }
+    static void newLine(std::string & buffer,int indentLevel) {
+        buffer += "\n";
+        for(int i=0; i<indentLevel; i++) buffer += "    ";
     }
 
+    Field::~Field(){}
 
-    bool ScalarTypeFunc::isInteger(ScalarType type) {
-        if(type>=pvByte && type<=pvLong) return true;
-        return false;
-    }
-
-    bool ScalarTypeFunc::isNumeric(ScalarType type) {
-        if(type>=pvByte && type<=pvDouble) return true;
-        return false;
-    }
-
-    bool ScalarTypeFunc::isPrimitive(ScalarType type) {
-        if(type>=pvBoolean && type<=pvDouble) return true;
-        return false;
-    }
-
-    ScalarType ScalarTypeFunc::getScalarType(std::string const& pvalue) {
-        static const std::string unknownString = "error unknown ScalarType";
-        if(pvalue.compare("boolean")==0) return pvBoolean;
-        if(pvalue.compare("byte")==0) return pvByte;
-        if(pvalue.compare("short")==0) return pvShort;
-        if(pvalue.compare("int")==0) return pvInt;
-        if(pvalue.compare("long")==0) return pvLong;
-        if(pvalue.compare("float")==0) return pvFloat;
-        if(pvalue.compare("double")==0) return pvDouble;
-        if(pvalue.compare("string")==0) return pvString;
-        throw std::invalid_argument(unknownString);
-    }
-    void ScalarTypeFunc::toString(std::string &buf,const ScalarType scalarType) {
-        static const std::string unknownString = "logic error unknown ScalarType";
-        switch(scalarType) {
-        case pvBoolean : buf += "pvBoolean"; return;
-        case pvByte : buf += "pvByte"; return;;
-        case pvShort : buf += "pvShort"; return;
-        case pvInt : buf += "pvInt"; return;
-        case pvLong : buf += "pvLong"; return;
-        case pvFloat : buf += "pvFloat"; return;
-        case pvDouble : buf += "pvDouble"; return;
-        case pvString : buf += "pvString"; return;
-        }
-        throw std::invalid_argument(unknownString);
-    }
-
-   Field::~Field(){}
-
-   class BaseField : public Field {
-   public:
+    class BaseField : public Field {
+    public:
        BaseField(std::string const& fieldName,Type type);
        ~BaseField();
        virtual std::string const& getFieldName() const;
        virtual Type getType() const;
        virtual void toString(std::string &buf) const;
        virtual void toString(std::string &buf,int indentLevel) const;
-   private:
+    private:
        std::string const fieldName;
        Type type;
     };
 
     BaseField::~BaseField() {
-        delete(&fieldName);
+        delete &fieldName;
     }
 
     BaseField::BaseField(std::string const& fieldName,Type type)
@@ -91,25 +41,26 @@ namespace epics { namespace pvData {
     Type BaseField::getType() const {return type;}
     void BaseField::toString(std::string &buf) const{toString(buf,0);}
     void BaseField::toString(std::string &buffer,int indentLevel) const{
-        for(int i=0; i<indentLevel; i++) buffer += "    ";
+        newLine(buffer,indentLevel);
         buffer += "field ";
         buffer += fieldName.c_str();
         buffer += " type ";
         TypeFunc::toString(buffer,type);
     }
 
-   Scalar::~Scalar(){}
+    Scalar::~Scalar(){}
 
-    class BaseScalar: public BaseField,public Scalar {
+    class BaseScalar: private BaseField,public Scalar {
     public:
         BaseScalar(std::string const& fieldName,ScalarType scalarType);
         ~BaseScalar();
-// WHY DO I HAVE TO DESCRIBE AND DEFINE THESE??
-virtual std::string const& getFieldName() const;
-virtual Type getType() const;
-       virtual ScalarType getScalarType() const { return scalarType;}
-       virtual void toString(std::string &buf) const;
-       virtual void toString(std::string &buf,int indentLevel) const;
+        virtual std::string const& getFieldName() const{
+            return BaseField::getFieldName();
+        }
+        virtual Type getType() const{return BaseField::getType();}
+        virtual ScalarType getScalarType() const { return scalarType;}
+        virtual void toString(std::string &buf) const {toString(buf,0);}
+        virtual void toString(std::string &buf,int indentLevel) const;
     private:
         ScalarType scalarType;
     };
@@ -119,44 +70,145 @@ virtual Type getType() const;
     BaseScalar::~BaseScalar() {}
 
 
-std::string const& BaseScalar::getFieldName() const
-{
-    return BaseField::getFieldName();
-}
-Type BaseScalar::getType() const
-{
-   return BaseField::getType();
-}
-    void BaseScalar::toString(std::string &buf) const{toString(buf,0);}
     void BaseScalar::toString(std::string &buffer,int indentLevel) const{
         BaseField::toString(buffer,indentLevel);
         buffer +=  " scalarType ";
         ScalarTypeFunc::toString(buffer,scalarType);
     }
 
+    ScalarArray::~ScalarArray(){}
+
+    class BaseScalarArray: private BaseField,public ScalarArray {
+    public:
+        BaseScalarArray(std::string const& fieldName,ScalarType elementType);
+        ~BaseScalarArray();
+        virtual std::string const& getFieldName() const{
+            return BaseField::getFieldName();
+        }
+        virtual Type getType() const{return BaseField::getType();}
+        virtual ScalarType getElementType() const { return elementType;}
+        virtual void toString(std::string &buf) const {toString(buf,0);}
+        virtual void toString(std::string &buf,int indentLevel) const;
+    private:
+        ScalarType elementType;
+    };
+
+    BaseScalarArray::BaseScalarArray
+           (std::string const& fieldName,ScalarType elementType)
+           : BaseField(fieldName,scalar),elementType(elementType){}
+    BaseScalarArray::~BaseScalarArray() {}
+
+
+    void BaseScalarArray::toString(std::string &buffer,int indentLevel) const{
+        BaseField::toString(buffer,indentLevel);
+        buffer +=  " elementType ";
+        ScalarTypeFunc::toString(buffer,elementType);
+    }
+
+    Structure::~Structure(){}
+
+    class BaseStructure: private BaseField,public Structure {
+    public:
+        BaseStructure(std::string const& fieldName,
+            int numberFields,FieldPtrConstArray fields);
+        ~BaseStructure();
+        virtual std::string const & getFieldName() const{
+            return BaseField::getFieldName();
+         }
+        virtual Type getType() const{return BaseField::getType();}
+        virtual int const getNumberFields() const {return numberFields;}
+        virtual StringPtrConstArray getFieldNames() const { return fieldNames;}
+        virtual FieldPtrConst getField(std::string const& fieldName) const;
+        virtual int getFieldIndex(std::string const& fieldName) const;
+        virtual FieldPtrConstArray getFields() const { return fields;}
+        virtual void toString(std::string &buf) const {toString(buf,0);}
+        virtual void toString(std::string &buf,int indentLevel) const;
+    private:
+        int numberFields;
+        FieldPtrConstArray  fields;
+        StringPtrConst* fieldNames;
+    };
+
+    BaseStructure::BaseStructure (std::string const& fieldName,
+        int numberFields, FieldPtrConstArray fields)
+        : BaseField(fieldName,structure),
+          numberFields(numberFields),
+          fields(fields),
+          fieldNames(new StringPtrConst[numberFields])
+    {
+        for(int i=0; i<numberFields; i++) {
+            fieldNames[i] = &fields[i]->getFieldName();
+        }
+    }
+    BaseStructure::~BaseStructure() {
+        for(int i=0; i<numberFields; i++) {
+            delete &fieldNames[i];
+        }
+	delete[] fieldNames;
+        delete[] fields;
+    }
+
+    FieldPtrConst  BaseStructure::getField(std::string const& fieldName) const {
+        for(int i=0; i<numberFields; i++) {
+            Field const &field =  *fields[i];
+            int result = fieldName.compare(field.getFieldName());
+            if(result==0) return &field;
+        }
+        return 0;
+    }
+
+    int BaseStructure::getFieldIndex(std::string const& fieldName) const {
+        for(int i=0; i<numberFields; i++) {
+            Field const &field =  *fields[i];
+            int result = fieldName.compare(field.getFieldName());
+            if(result==0) return i;
+        }
+        return -1;
+    }
+
+    void BaseStructure::toString(std::string &buffer,int indentLevel) const{
+        BaseField::toString(buffer,indentLevel);
+        buffer += " {";
+        for(int i=0; i<numberFields; i++) {
+            Field const &field =  *fields[i];
+            field.toString(buffer,indentLevel+1);
+        }
+        newLine(buffer,indentLevel);
+        buffer +=  "}";
+    }
+
 static std::string notImplemented = "not implemented";
 
   FieldCreate::FieldCreate(){};
 
-   Field const & FieldCreate::create(std::string const& fieldName, Field const & field) const
+   Field const & FieldCreate::create(std::string const& fieldName,
+       Field const & field) const
    {
         throw std::invalid_argument(notImplemented);
    }
-   Scalar const &  FieldCreate::createScalar(std::string const& fieldName,ScalarType scalarType) const
+   Scalar const &  FieldCreate::createScalar(std::string const& fieldName,
+       ScalarType scalarType) const
    {
          BaseScalar *baseScalar = new BaseScalar(fieldName,scalarType);
          return *baseScalar;
    }
  
-   ScalarArray const & FieldCreate::createScalarArray(std::string const& fieldName,ScalarType elementType) const
+   ScalarArray const & FieldCreate::createScalarArray(
+       std::string const& fieldName,ScalarType elementType) const
    {
-        throw std::invalid_argument(notImplemented);
+         BaseScalarArray *baseScalarArray = new BaseScalarArray(fieldName,elementType);
+         return *baseScalarArray;
    }
-   Structure const & FieldCreate::createStructure (std::string const& fieldName,Field const * const fields) const
+   Structure const & FieldCreate::createStructure (
+       std::string const& fieldName,int numberFields,
+       FieldPtrConst fields[]) const
    {
-        throw std::invalid_argument(notImplemented);
+         BaseStructure *baseStructure = new BaseStructure(
+             fieldName,numberFields,fields);
+         return *baseStructure;
    }
-   StructureArray const & FieldCreate::createStructureArray(std::string const& fieldName,Structure const & structure) const
+   StructureArray const & FieldCreate::createStructureArray(
+       std::string const& fieldName,Structure const & structure) const
    {
         throw std::invalid_argument(notImplemented);
    }
diff --git a/pvDataApp/factory/Makefile b/pvDataApp/factory/Makefile
index 9c5eba5..b8eba6e 100644
--- a/pvDataApp/factory/Makefile
+++ b/pvDataApp/factory/Makefile
@@ -2,6 +2,7 @@ TOP=../..
 
 include $(TOP)/configure/CONFIG
 
+LIBSRCS += TypeFunc.cpp
 LIBSRCS += FieldCreateFactory.cpp
 
 LIBRARY=pvFactory
diff --git a/pvDataApp/factory/TypeFunc.cpp b/pvDataApp/factory/TypeFunc.cpp
new file mode 100644
index 0000000..dcdee1e
--- /dev/null
+++ b/pvDataApp/factory/TypeFunc.cpp
@@ -0,0 +1,69 @@
+
+#include <cstddef>
+#include <cstdlib>
+#include <string>
+#include <cstdio>
+
+#include <boost/smart_ptr.hpp>
+
+#include "pvData.h"
+
+namespace epics { namespace pvData {
+
+    void TypeFunc::toString(std::string &buf,const Type type) {
+        static const std::string unknownString = "logic error unknown Type";
+        switch(type) {
+        case scalar : buf += "scalar"; break;
+        case scalarArray : buf += "scalarArray"; break;
+        case structure : buf += "structure"; break;
+        case structureArray : buf += "structureArray"; break;
+        default:
+        throw std::invalid_argument(unknownString);
+        }
+    }
+
+
+    bool ScalarTypeFunc::isInteger(ScalarType type) {
+        if(type>=pvByte && type<=pvLong) return true;
+        return false;
+    }
+
+    bool ScalarTypeFunc::isNumeric(ScalarType type) {
+        if(type>=pvByte && type<=pvDouble) return true;
+        return false;
+    }
+
+    bool ScalarTypeFunc::isPrimitive(ScalarType type) {
+        if(type>=pvBoolean && type<=pvDouble) return true;
+        return false;
+    }
+
+    ScalarType ScalarTypeFunc::getScalarType(std::string const& pvalue) {
+        static const std::string unknownString = "error unknown ScalarType";
+        if(pvalue.compare("boolean")==0) return pvBoolean;
+        if(pvalue.compare("byte")==0) return pvByte;
+        if(pvalue.compare("short")==0) return pvShort;
+        if(pvalue.compare("int")==0) return pvInt;
+        if(pvalue.compare("long")==0) return pvLong;
+        if(pvalue.compare("float")==0) return pvFloat;
+        if(pvalue.compare("double")==0) return pvDouble;
+        if(pvalue.compare("string")==0) return pvString;
+        throw std::invalid_argument(unknownString);
+    }
+    void ScalarTypeFunc::toString(std::string &buf,const ScalarType scalarType) {
+        static const std::string unknownString = "logic error unknown ScalarType";
+        switch(scalarType) {
+        case pvBoolean : buf += "pvBoolean"; return;
+        case pvByte : buf += "pvByte"; return;;
+        case pvShort : buf += "pvShort"; return;
+        case pvInt : buf += "pvInt"; return;
+        case pvLong : buf += "pvLong"; return;
+        case pvFloat : buf += "pvFloat"; return;
+        case pvDouble : buf += "pvDouble"; return;
+        case pvString : buf += "pvString"; return;
+        }
+        throw std::invalid_argument(unknownString);
+    }
+
+
+}}
diff --git a/pvDataApp/pv/pvData.h b/pvDataApp/pv/pvData.h
index 5d72e78..2c674ee 100644
--- a/pvDataApp/pv/pvData.h
+++ b/pvDataApp/pv/pvData.h
@@ -61,16 +61,22 @@ namespace epics { namespace pvData {
     class ScalarArray : public Field{
     public:
        virtual ~ScalarArray();
-       virtual ScalarType  getScalerType() const = 0;
+       virtual ScalarType  getElementType() const = 0;
     };
 
+    typedef Field const * FieldPtrConst;
+    typedef FieldPtrConst * FieldPtrConstArray;
+    typedef std::string const * StringPtrConst;
+    typedef StringPtrConst * StringPtrConstArray;
+
     class Structure : public Field {
     public:
        virtual ~Structure();
-       virtual std::string const * const getFieldNames() const = 0;
-       virtual Field const &  getField(std::string const& fieldName) const = 0;
+       virtual int const getNumberFields() const = 0;
+       virtual StringPtrConstArray getFieldNames() const = 0;
+       virtual FieldPtrConst getField(std::string const& fieldName) const = 0;
        virtual int getFieldIndex(std::string const& fieldName) const = 0;
-       virtual Field const * const getFields() const = 0;
+       virtual FieldPtrConstArray getFields() const = 0;
     };
 
     class StructureArray : public Field{
@@ -85,7 +91,7 @@ namespace epics { namespace pvData {
        Field const &  create(std::string const& fieldName,Field const &  field) const;
        Scalar const &  createScalar(std::string const& fieldName,ScalarType scalarType) const;
        ScalarArray const & createScalarArray(std::string const& fieldName,ScalarType elementType) const;
-       Structure const & createStructure (std::string const& fieldName,Field const * const  fields) const;
+       Structure const & createStructure (std::string const& fieldName,int numberFields,FieldPtrConstArray fields) const;
        StructureArray const & createStructureArray(std::string const& fieldName,Structure const & structure) const;
     protected:
        FieldCreate();
diff --git a/pvDataApp/test/test.cpp b/pvDataApp/test/test.cpp
index 9b27d8f..2f974a8 100644
--- a/pvDataApp/test/test.cpp
+++ b/pvDataApp/test/test.cpp
@@ -39,5 +39,19 @@ int main(int argc,char *argv[])
     myString->clear();
     scalar.toString(*myString);
     printf("%s\n",myString->c_str());
+    ScalarArray const & scalarArray = fieldCreate.createScalarArray(valueName,pvString);
+    myString->clear();
+    scalarArray.toString(*myString);
+    printf("%s\n",myString->c_str());
+    int numberFields = 2;
+    FieldPtrConst fields[numberFields];
+    std::string  name0("high");
+    std::string  name1("low");
+    fields[0] = &fieldCreate.createScalar(name0,pvDouble);
+    fields[1] = &fieldCreate.createScalar(name1,pvDouble);
+    Structure const & structure = fieldCreate.createStructure(valueName,numberFields,fields);
+    myString->clear();
+    structure.toString(*myString);
+    printf("%s\n",myString->c_str());
     return(0);
 }