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

PVDataCreateFactory.cpp now complete

Browse Source
This commit is contained in:
Marty Kraimer
2010-10-21 16:23:28 -04:00
parent c497b9b334
commit fce7b9914b
6 changed files with 249 additions and 192 deletions
Download Patch File Download Diff File Expand all files Collapse all files

52
pvDataApp/factory/BasePVStructureArray.h
View File

@@ -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 */

4
pvDataApp/factory/PVAuxInfoImpl.cpp
View File

@@ -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)

351
pvDataApp/factory/PVDataCreateFactory.cpp
View File

@@ -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;
}
}}

32
pvDataApp/pv/pvData.h
View File

@@ -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:

1
pvDataApp/test/Makefile
View File

@@ -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

1
pvDataApp/test/testPVScalar.cpp
View File

@@ -6,6 +6,7 @@
#include <stddef.h>
#include <string.h>
#include <stdio.h>
#include <epicsAssert.h>
#include "requester.h"
#include "pvIntrospect.h"