epics/pvData
0
0
Fork 0
Code Issues Pull Requests Projects Wiki Activity

Working on initial version

Browse Source
This commit is contained in:
Marty Kraimer
2010-09-15 06:54:43 -04:00
parent 71aa16dc16
commit ac194e1123
6 changed files with 287 additions and 219 deletions
Download Patch File Download Diff File Expand all files Collapse all files
pvDataApp/factory/FieldCreateFactory.cpp
+129 -81
View File
@@ -3,28 +3,26 @@
#include <cstdlib>
#include <string>
#include <cstdio>
#include <boost/smart_ptr.hpp>
#include "pvData.h"
namespace epics { namespace pvData {
static void newLine(std::string & buffer,int indentLevel) {
buffer += "\n";
for(int i=0; i<indentLevel; i++) buffer += " ";
static void newLine(StringPtr buffer,int indentLevel) {
*buffer += "\n";
for(int i=0; i<indentLevel; i++) *buffer += " ";
}
Field::~Field(){}
class BaseField : public Field {
public:
BaseField(std::string const& fieldName,Type type);
~BaseField();
virtual std::string const& getFieldName() const;
BaseField(StringConstPtr fieldName,Type type);
virtual ~BaseField();
virtual StringConstPtr getFieldName() const;
virtual Type getType() const;
virtual void toString(std::string &buf) const;
virtual void toString(std::string &buf,int indentLevel) const;
virtual void toString(StringPtr buf) const;
virtual void toString(StringPtr buf,int indentLevel) const;
private:
std::string const fieldName;
Type type;
@@ -34,17 +32,17 @@ namespace epics { namespace pvData {
delete &fieldName;
}
BaseField::BaseField(std::string const& fieldName,Type type)
:fieldName(fieldName),type(type){}
BaseField::BaseField(StringConstPtr fieldName,Type type)
:fieldName(*fieldName),type(type){}
std::string const& BaseField::getFieldName() const {return fieldName;}
StringConstPtr BaseField::getFieldName() const {return &fieldName;}
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{
void BaseField::toString(StringPtr buf) const{toString(buf,0);}
void BaseField::toString(StringPtr buffer,int indentLevel) const{
newLine(buffer,indentLevel);
buffer += "field ";
buffer += fieldName.c_str();
buffer += " type ";
*buffer += "field ";
*buffer += fieldName.c_str();
*buffer += " type ";
TypeFunc::toString(buffer,type);
}
@@ -52,27 +50,27 @@ namespace epics { namespace pvData {
class BaseScalar: private BaseField,public Scalar {
public:
BaseScalar(std::string const& fieldName,ScalarType scalarType);
~BaseScalar();
virtual std::string const& getFieldName() const{
BaseScalar(StringConstPtr fieldName,ScalarType scalarType);
virtual ~BaseScalar();
virtual StringConstPtr 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;
virtual void toString(StringPtr buf) const {toString(buf,0);}
virtual void toString(StringPtr buf,int indentLevel) const;
private:
ScalarType scalarType;
};
BaseScalar::BaseScalar(std::string const& fieldName,ScalarType scalarType)
BaseScalar::BaseScalar(StringConstPtr fieldName,ScalarType scalarType)
: BaseField(fieldName,scalar),scalarType(scalarType){}
BaseScalar::~BaseScalar() {}
void BaseScalar::toString(std::string &buffer,int indentLevel) const{
void BaseScalar::toString(StringPtr buffer,int indentLevel) const{
BaseField::toString(buffer,indentLevel);
buffer += " scalarType ";
*buffer += " scalarType ";
ScalarTypeFunc::toString(buffer,scalarType);
}
@@ -80,28 +78,28 @@ namespace epics { namespace pvData {
class BaseScalarArray: private BaseField,public ScalarArray {
public:
BaseScalarArray(std::string const& fieldName,ScalarType elementType);
~BaseScalarArray();
virtual std::string const& getFieldName() const{
BaseScalarArray(StringConstPtr fieldName,ScalarType elementType);
virtual ~BaseScalarArray();
virtual StringConstPtr 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;
virtual void toString(StringPtr buf) const {toString(buf,0);}
virtual void toString(StringPtr buf,int indentLevel) const;
private:
ScalarType elementType;
};
BaseScalarArray::BaseScalarArray
(std::string const& fieldName,ScalarType elementType)
(StringConstPtr fieldName,ScalarType elementType)
: BaseField(fieldName,scalar),elementType(elementType){}
BaseScalarArray::~BaseScalarArray() {}
void BaseScalarArray::toString(std::string &buffer,int indentLevel) const{
void BaseScalarArray::toString(StringPtr buffer,int indentLevel) const{
BaseField::toString(buffer,indentLevel);
buffer += " elementType ";
*buffer += " elementType ";
ScalarTypeFunc::toString(buffer,elementType);
}
@@ -109,110 +107,160 @@ namespace epics { namespace pvData {
class BaseStructure: private BaseField,public Structure {
public:
BaseStructure(std::string const& fieldName,
int numberFields,FieldPtrConstArray fields);
~BaseStructure();
virtual std::string const & getFieldName() const{
BaseStructure(StringConstPtr fieldName,
int numberFields,FieldConstPtrArray fields);
virtual ~BaseStructure();
virtual StringConstPtr 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;
virtual StringConstPtrArray getFieldNames() const { return fieldNames;}
virtual FieldConstPtr getField(StringConstPtr fieldName) const;
virtual int getFieldIndex(StringConstPtr fieldName) const;
virtual FieldConstPtrArray getFields() const { return fields;}
virtual void toString(StringPtr buf) const {toString(buf,0);}
virtual void toString(StringPtr buf,int indentLevel) const;
private:
int numberFields;
FieldPtrConstArray fields;
StringPtrConst* fieldNames;
FieldConstPtrArray fields;
StringConstPtr* fieldNames;
};
BaseStructure::BaseStructure (std::string const& fieldName,
int numberFields, FieldPtrConstArray fields)
BaseStructure::BaseStructure (StringConstPtr fieldName,
int numberFields, FieldConstPtrArray fields)
: BaseField(fieldName,structure),
numberFields(numberFields),
fields(fields),
fieldNames(new StringPtrConst[numberFields])
fieldNames(new StringConstPtr[numberFields])
{
for(int i=0; i<numberFields; i++) {
fieldNames[i] = &fields[i]->getFieldName();
fieldNames[i] = fields[i]->getFieldName();
}
}
BaseStructure::~BaseStructure() {
for(int i=0; i<numberFields; i++) {
delete &fieldNames[i];
delete fieldNames[i];
}
delete[] fieldNames;
delete[] fields;
}
FieldPtrConst BaseStructure::getField(std::string const& fieldName) const {
FieldConstPtr BaseStructure::getField(StringConstPtr 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;
FieldConstPtr pfield = fields[i];
int result = fieldName->compare(*pfield->getFieldName());
if(result==0) return pfield;
}
return 0;
}
int BaseStructure::getFieldIndex(std::string const& fieldName) const {
int BaseStructure::getFieldIndex(StringConstPtr fieldName) const {
for(int i=0; i<numberFields; i++) {
Field const &field = *fields[i];
int result = fieldName.compare(field.getFieldName());
FieldConstPtr pfield = fields[i];
int result = fieldName->compare(*pfield->getFieldName());
if(result==0) return i;
}
return -1;
}
void BaseStructure::toString(std::string &buffer,int indentLevel) const{
void BaseStructure::toString(StringPtr buffer,int indentLevel) const{
BaseField::toString(buffer,indentLevel);
buffer += " {";
*buffer += " {";
for(int i=0; i<numberFields; i++) {
Field const &field = *fields[i];
field.toString(buffer,indentLevel+1);
FieldConstPtr pfield = fields[i];
pfield->toString(buffer,indentLevel+1);
}
newLine(buffer,indentLevel);
buffer += "}";
*buffer += "}";
}
StructureArray::~StructureArray(){}
class BaseStructureArray: private BaseField,public StructureArray {
public:
BaseStructureArray(StringConstPtr fieldName,StructureConstPtr structure);
virtual ~BaseStructureArray();
virtual StringConstPtr getFieldName() const{
return BaseField::getFieldName();
}
virtual Type getType() const{return BaseField::getType();}
virtual StructureConstPtr getStructure() const { return pstructure; }
virtual void toString(StringPtr buf) const {toString(buf,0);}
virtual void toString(StringPtr buf,int indentLevel) const;
private:
StructureConstPtr pstructure;
};
BaseStructureArray::BaseStructureArray(StringConstPtr fieldName,StructureConstPtr structure)
: BaseField(fieldName,structureArray),pstructure(structure) {}
BaseStructureArray::~BaseStructureArray() {}
void BaseStructureArray::toString(StringPtr buffer,int indentLevel) const {
BaseField::toString(buffer,indentLevel);
*buffer += " structure ";
pstructure->toString(buffer,indentLevel + 1);
}
static std::string notImplemented = "not implemented";
static std::string logicError = "Logic Error. Should never get here";
FieldCreate::FieldCreate(){};
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,
ScalarConstPtr FieldCreate::createScalar(StringConstPtr fieldName,
ScalarType scalarType) const
{
BaseScalar *baseScalar = new BaseScalar(fieldName,scalarType);
return *baseScalar;
return baseScalar;
}
ScalarArray const & FieldCreate::createScalarArray(
std::string const& fieldName,ScalarType elementType) const
ScalarArrayConstPtr FieldCreate::createScalarArray(
StringConstPtr fieldName,ScalarType elementType) const
{
BaseScalarArray *baseScalarArray = new BaseScalarArray(fieldName,elementType);
return *baseScalarArray;
return baseScalarArray;
}
Structure const & FieldCreate::createStructure (
std::string const& fieldName,int numberFields,
FieldPtrConst fields[]) const
StructureConstPtr FieldCreate::createStructure (
StringConstPtr fieldName,int numberFields,
FieldConstPtr fields[]) const
{
BaseStructure *baseStructure = new BaseStructure(
fieldName,numberFields,fields);
return *baseStructure;
return baseStructure;
}
StructureArray const & FieldCreate::createStructureArray(
std::string const& fieldName,Structure const & structure) const
StructureArrayConstPtr FieldCreate::createStructureArray(
StringConstPtr fieldName,StructureConstPtr structure) const
{
throw std::invalid_argument(notImplemented);
}
FieldConstPtr FieldCreate::create(StringConstPtr fieldName,
FieldConstPtr pfield) const
{
Type type = pfield->getType();
switch(type) {
case scalar: {
ScalarConstPtr pscalar = dynamic_cast<ScalarConstPtr>(pfield);
return createScalar(fieldName,pscalar->getScalarType());
}
case scalarArray: {
ScalarArrayConstPtr pscalarArray = dynamic_cast<ScalarArrayConstPtr>(pfield);
return createScalarArray(fieldName,pscalarArray->getElementType());
}
case structure: {
StructureConstPtr pstructure = dynamic_cast<StructureConstPtr>(pfield);
return createStructure(fieldName,pstructure->getNumberFields(),pstructure->getFields());
}
case structureArray: {
StructureArrayConstPtr pstructureArray = dynamic_cast<StructureArrayConstPtr>(pfield);
return createStructureArray(fieldName,pstructureArray->getStructure());
}
}
throw std::logic_error(logicError);
}
static FieldCreate* instance = 0;
class FieldCreateExt : public FieldCreate {
@@ -220,9 +268,9 @@ static std::string notImplemented = "not implemented";
FieldCreateExt(): FieldCreate(){};
};
FieldCreate & getFieldCreate() {
FieldCreate * getFieldCreate() {
if(instance==0) instance = new FieldCreateExt();
return *instance;
return instance;
}
}}