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

1) implemented noDefaultMethods. See effective C++ Item 6. There it is called Uncopyable

Browse Source 
2) implemented Lock. See effective C++ item 14.
     This is as easy to use as Java synchronize.
3) wrapper on top of std::string. All usage of string in pvData is one of:
      String - Just a std::string
     StringBuilder - Used where StringBuilder is used in Java
     StringConst - Just a "std::string const". This is used wherever String is used in Java
     StringConstArray - Just like a String[] in Java.
4) The reference counting (incReferenceCount and decReferenceCount) are now private. It is completely handled by the implenentaion.
    NO code that uses pvData needs even know about reference counting.
This commit is contained in:
Marty Kraimer
2010-09-27 08:33:10 -04:00
parent dd6ecf9bec
commit f6c9b0eea3
26 changed files with 377 additions and 522 deletions
Download Patch File Download Diff File Expand all files Collapse all files

16
pvDataApp/factory/AbstractPVArray.h
View File

@@ -30,11 +30,11 @@ namespace epics { namespace pvData {
int PVArray::getLength() const {return pImpl->length;}
static std::string fieldImmutable("field is immutable");
static StringConst fieldImmutable("field is immutable");
void PVArray::setLength(int length) {
if(PVField::isImmutable()) {
PVField::message(&fieldImmutable,errorMessage);
PVField::message(fieldImmutable,errorMessage);
return;
}
if(length>pImpl->capacity) this->setCapacity(length);
@@ -54,29 +54,29 @@ namespace epics { namespace pvData {
void PVArray::setCapacityImmutable(epicsBoolean isMutable)
{
if(isMutable && PVField::isImmutable()) {
PVField::message(&fieldImmutable,errorMessage);
PVField::message(fieldImmutable,errorMessage);
return;
}
pImpl->capacityMutable = isMutable;
}
static std::string capacityImmutable("capacity is immutable");
static StringConst capacityImmutable("capacity is immutable");
void PVArray::setCapacity(int capacity) {
if(PVField::isImmutable()) {
PVField::message(&fieldImmutable,errorMessage);
PVField::message(fieldImmutable,errorMessage);
return;
}
if(pImpl->capacityMutable==epicsFalse) {
PVField::message(&capacityImmutable,errorMessage);
PVField::message(capacityImmutable,errorMessage);
return;
}
pImpl->capacity = capacity;
}
void PVArray::toString(StringPtr buf) const {toString(buf,0);}
void PVArray::toString(StringBuilder buf) const {toString(buf,0);}
void PVArray::toString(StringPtr buf, int indentLevel) const
void PVArray::toString(StringBuilder buf, int indentLevel) const
{
throw std::logic_error(notImplemented);
}

22
pvDataApp/factory/AbstractPVField.h
View File

@@ -11,7 +11,7 @@
namespace epics { namespace pvData {
static std::string notImplemented("not implemented");
static StringConst notImplemented("not implemented");
static Convert *convert = 0;
@@ -60,27 +60,27 @@ static std::string notImplemented("not implemented");
delete pImpl;
}
StringConstPtr PVField::getRequesterName() const
StringConst PVField::getRequesterName() const
{
static std::string none("none");
static StringConst none("none");
if(pImpl->requester!=0) return pImpl->requester->getRequesterName();
return &none;
return none;
}
void PVField::message(StringConstPtr message,MessageType messageType) const
void PVField::message(StringConst message,MessageType messageType) const
{
if(pImpl->requester) {
pImpl->requester->message(message,messageType);
} else {
printf("%s %s %s\n",
messageTypeName[messageType].c_str(),
pImpl->field->getFieldName()->c_str(),
message->c_str());
pImpl->field->getFieldName().c_str(),
message.c_str());
}
}
void PVField::setRequester(Requester *prequester)
{
static std::string requesterPresent =
static StringConst requesterPresent =
"Logic Error. requester is already present";
if(pImpl->requester==0) {
pImpl->requester = prequester;
@@ -127,7 +127,7 @@ static std::string notImplemented("not implemented");
throw std::logic_error(notImplemented);
}
void PVField::renameField(StringConstPtr newName)
void PVField::renameField(StringConst newName)
{
throw std::logic_error(notImplemented);
}
@@ -142,9 +142,9 @@ static std::string notImplemented("not implemented");
throw std::logic_error(notImplemented);
}
void PVField::toString(StringPtr buf) const {toString(buf,0);}
void PVField::toString(StringBuilder buf) const {toString(buf,0);}
void PVField::toString(StringPtr buf,int indentLevel) const
void PVField::toString(StringBuilder buf,int indentLevel) const
{
throw std::logic_error(notImplemented);
}

12
pvDataApp/factory/BasePVDouble.h
View File

@@ -24,16 +24,12 @@ namespace epics { namespace pvData {
SerializableControl *pflusher) const;
virtual void deserialize(ByteBuffer *pbuffer,
DeserializableControl *pflusher);
virtual void toString(StringPtr buf)const;
virtual void toString(StringPtr buf,int indentLevel)const;
virtual void toString(StringBuilder buf)const;
virtual void toString(StringBuilder buf,int indentLevel)const;
private:
BasePVDouble(); // not implemented
BasePVDouble(BasePVDouble const & ); // not implemented
BasePVDouble & operator=(BasePVDouble const &); //not implemented
double value;
};
BasePVDouble::BasePVDouble(PVStructure *parent,ScalarConstPtr scalar)
: PVDouble(parent,scalar),value(0.0)
{}
@@ -56,9 +52,9 @@ namespace epics { namespace pvData {
throw std::logic_error(notImplemented);
}
void BasePVDouble::toString(StringPtr buf)const {toString(buf,0);}
void BasePVDouble::toString(StringBuilder buf)const {toString(buf,0);}
void BasePVDouble::toString(StringPtr buf,int indentLevel) const
void BasePVDouble::toString(StringBuilder buf,int indentLevel) const
{
convert->getString(buf,this,indentLevel);
PVField::toString(buf,indentLevel);

11
pvDataApp/factory/BasePVDoubleArray.h
View File

@@ -30,11 +30,10 @@ namespace epics { namespace pvData {
virtual void deserialize(ByteBuffer *pbuffer,DeserializableControl *pflusher);
virtual void serialize(ByteBuffer *pbuffer,
SerializableControl *pflusher, int offset, int count) const;
virtual void toString(StringPtr buf)const;
virtual void toString(StringPtr buf,int indentLevel)const;
virtual void toString(StringBuilder buf)const;
virtual void toString(StringBuilder buf,int indentLevel)const;
private:
BasePVDoubleArray(); // not implemented
DoubleArrayPtr doubleArray;
double *doubleArray;
};
BasePVDoubleArray::BasePVDoubleArray(PVStructure *parent,
@@ -88,12 +87,12 @@ namespace epics { namespace pvData {
throw std::logic_error(notImplemented);
}
void BasePVDoubleArray::toString(StringPtr buf)const
void BasePVDoubleArray::toString(StringBuilder buf)const
{
toString(buf,1);
}
void BasePVDoubleArray::toString(StringPtr buf,int indentLevel)const
void BasePVDoubleArray::toString(StringBuilder buf,int indentLevel)const
{
convert->getString(buf,this,indentLevel);
PVArray::toString(buf,indentLevel);

40
pvDataApp/factory/BasePVStructure.h
View File

@@ -17,7 +17,7 @@ namespace epics { namespace pvData {
int numberFields;
PVFieldArrayPtr pvFields;
std::string const extendsStructureName;
StringConst const extendsStructureName;
};
PVStructurePvt::PVStructurePvt()
@@ -58,7 +58,7 @@ namespace epics { namespace pvData {
return pImpl->pvFields;
}
PVFieldPtr PVStructure::getSubField(StringConstPtr fieldName)
PVFieldPtr PVStructure::getSubField(StringConst fieldName)
{
throw std::logic_error(notImplemented);
}
@@ -78,82 +78,82 @@ namespace epics { namespace pvData {
throw std::logic_error(notImplemented);
}
void PVStructure::removePVField(StringConstPtr fieldName)
void PVStructure::removePVField(StringConst fieldName)
{
throw std::logic_error(notImplemented);
}
PVBoolean *PVStructure::getBooleanField(StringConstPtr fieldName)
PVBoolean *PVStructure::getBooleanField(StringConst fieldName)
{
throw std::logic_error(notImplemented);
}
PVByte *PVStructure::getByteField(StringConstPtr fieldName)
PVByte *PVStructure::getByteField(StringConst fieldName)
{
throw std::logic_error(notImplemented);
}
PVShort *PVStructure::getShortField(StringConstPtr fieldName)
PVShort *PVStructure::getShortField(StringConst fieldName)
{
throw std::logic_error(notImplemented);
}
PVInt *PVStructure::getIntField(StringConstPtr fieldName)
PVInt *PVStructure::getIntField(StringConst fieldName)
{
throw std::logic_error(notImplemented);
}
PVLong *PVStructure::getLongField(StringConstPtr fieldName)
PVLong *PVStructure::getLongField(StringConst fieldName)
{
throw std::logic_error(notImplemented);
}
PVFloat *PVStructure::getFloatField(StringConstPtr fieldName)
PVFloat *PVStructure::getFloatField(StringConst fieldName)
{
throw std::logic_error(notImplemented);
}
PVDouble *PVStructure::getDoubleField(StringConstPtr fieldName)
PVDouble *PVStructure::getDoubleField(StringConst fieldName)
{
throw std::logic_error(notImplemented);
}
PVString *PVStructure::getStringField(StringConstPtr fieldName)
PVString *PVStructure::getStringField(StringConst fieldName)
{
throw std::logic_error(notImplemented);
}
PVStructure *PVStructure::getStructureField(StringConstPtr fieldName)
PVStructure *PVStructure::getStructureField(StringConst fieldName)
{
throw std::logic_error(notImplemented);
}
PVScalarArray *PVStructure::getScalarArrayField(
StringConstPtr fieldName,ScalarType elementType)
StringConst fieldName,ScalarType elementType)
{
throw std::logic_error(notImplemented);
}
PVStructureArray *PVStructure::getStructureArrayField(
StringConstPtr fieldName)
StringConst fieldName)
{
throw std::logic_error(notImplemented);
}
StringConstPtr PVStructure::getExtendsStructureName()
StringConst PVStructure::getExtendsStructureName()
{
throw std::logic_error(notImplemented);
}
epicsBoolean PVStructure::putExtendsStructureName(
StringConstPtr extendsStructureName)
StringConst extendsStructureName)
{
throw std::logic_error(notImplemented);
}
void PVStructure::toString(StringPtr buf) const {toString(buf,0);}
void PVStructure::toString(StringBuilder buf) const {toString(buf,0);}
void PVStructure::toString(StringPtr buf,int indentLevel) const
void PVStructure::toString(StringBuilder buf,int indentLevel) const
{
throw std::logic_error(notImplemented);
}
@@ -193,10 +193,6 @@ namespace epics { namespace pvData {
BasePVStructure(PVStructure *parent,StructureConstPtr structure);
~BasePVStructure();
private:
BasePVStructure(); // not implemented
BasePVStructure(BasePVStructure const & ); // not implemented
BasePVStructure& operator=(BasePVStructure const &); //not implemented
};
BasePVStructure::BasePVStructure(PVStructure *parent,StructureConstPtr structure)

8
pvDataApp/factory/BasePVStructureArray.h
View File

@@ -85,9 +85,9 @@ namespace epics { namespace pvData {
throw std::logic_error(notImplemented);
}
void PVStructureArray::toString(StringPtr buf) const {toString(buf,0);}
void PVStructureArray::toString(StringBuilder buf) const {toString(buf,0);}
void PVStructureArray::toString(StringPtr buf,int indentLevel) const
void PVStructureArray::toString(StringBuilder buf,int indentLevel) const
{
throw std::logic_error(notImplemented);
}
@@ -99,10 +99,6 @@ namespace epics { namespace pvData {
: PVStructureArray(parent,structureArray) {}
~BasePVStructureArray(){}
private:
// following not implemented
BasePVStructureArray();
BasePVStructureArray(BasePVStructureArray const & );
BasePVStructureArray & operator=(BasePVStructureArray const &);
};
}}

26
pvDataApp/factory/Convert.cpp
View File

@@ -1,7 +1,7 @@
/* Convert.cpp */
#include <string>
#include <stdexcept>
#include <epicsMutex.h>
#include <lock.h>
#include "convert.h"
namespace epics { namespace pvData {
@@ -12,39 +12,39 @@ static std::string notImplemented("not implemented");
Convert::~Convert(){}
void Convert::getFullName(StringConstPtr buf,PVField const *pvField)
void Convert::getFullName(StringConst buf,PVField const *pvField)
{
throw std::logic_error(notImplemented);
}
void Convert::getString(StringPtr buf,PVField const * pvField,int indentLevel)
void Convert::getString(StringBuilder buf,PVField const * pvField,int indentLevel)
{
throw std::logic_error(notImplemented);
}
void Convert::getString(StringPtr buf,PVField const *pvField)
void Convert::getString(StringBuilder buf,PVField const *pvField)
{
throw std::logic_error(notImplemented);
}
void Convert::fromString(PVScalar *pv, StringConstPtr from)
void Convert::fromString(PVScalar *pv, StringConst from)
{
throw std::logic_error(notImplemented);
}
int Convert::fromString(PVScalarArray *pv, StringConstPtr from)
int Convert::fromString(PVScalarArray *pv, StringConst from)
{
throw std::logic_error(notImplemented);
}
int Convert::fromStringArray(PVScalarArray *pv, int offset, int length,
StringPtrArray from, int fromOffset)
StringConstArray from, int fromOffset)
{
throw std::logic_error(notImplemented);
}
int Convert::toStringArray(PVScalarArray const *pv, int offset, int length,
StringPtrArray to, int fromOffset)
StringConstArray to, int fromOffset)
{
throw std::logic_error(notImplemented);
}
@@ -237,7 +237,7 @@ static std::string notImplemented("not implemented");
throw std::logic_error(notImplemented);
}
void Convert::newLine(StringPtr buffer, int indentLevel)
void Convert::newLine(StringBuilder buffer, int indentLevel)
{
*buffer += "\n";
for(int i=0; i<indentLevel; i++) *buffer += " ";
@@ -253,10 +253,10 @@ static std::string notImplemented("not implemented");
};
Convert * getConvert() {
static epicsMutex *lock = new epicsMutex();
lock->lock();
if(instance==0) instance = new ConvertExt();
lock->unlock();
static Mutex *mutex = new Mutex();
Lock xx(mutex);
if(instance==0) instance = new ConvertExt();
return instance;
}

117
pvDataApp/factory/FieldCreateFactory.cpp
View File

@@ -3,13 +3,14 @@
#include <cstdlib>
#include <string>
#include <cstdio>
#include <epicsMutex.h>
#include <lock.h>
#include "pvIntrospect.h"
#include "factory.h"
namespace epics { namespace pvData {
static void newLine(StringPtr buffer, int indentLevel)
static DebugLevel debugLevel = highDebug;
static void newLine(StringBuilder buffer, int indentLevel)
{
*buffer += "\n";
for(int i=0; i<indentLevel; i++) *buffer += " ";
@@ -19,25 +20,23 @@ namespace epics { namespace pvData {
class BaseField : public Field {
public:
BaseField(StringConstPtr fieldName,Type type);
BaseField(StringConst fieldName,Type type);
virtual ~BaseField();
virtual void decReferenceCount() const;
virtual void incReferenceCount() const {referenceCount++;}
virtual int getReferenceCount() const {return referenceCount;}
virtual StringConstPtr getFieldName() const {return &fieldName;}
virtual StringConst getFieldName() const {return fieldName;}
virtual Type getType() const {return type;}
virtual void toString(StringPtr buf) const {return toString(buf,0);}
virtual void toString(StringPtr buf,int indentLevel) const;
virtual void toString(StringBuilder buf) const {return toString(buf,0);}
virtual void toString(StringBuilder buf,int indentLevel) const;
private:
BaseField(BaseField const & ); // not implemented
BaseField & operator=(BaseField const &); //not implemented
std::string const fieldName;
StringConst fieldName;
Type type;
mutable volatile int referenceCount;
};
BaseField::BaseField(StringConstPtr fieldName,Type type)
:fieldName(*fieldName),type(type), referenceCount(0){}
BaseField::BaseField(StringConst fieldName,Type type)
:fieldName(fieldName),type(type), referenceCount(0){}
BaseField::~BaseField() {
// note that c++ automatically calls destructor for fieldName
@@ -46,7 +45,7 @@ namespace epics { namespace pvData {
void BaseField::decReferenceCount() const {
if(referenceCount<=0) {
std::string message("logicError field ");
String message("logicError field ");
message += fieldName;
throw std::logic_error(message);
}
@@ -54,7 +53,7 @@ namespace epics { namespace pvData {
if(referenceCount==0) delete this;
}
void BaseField::toString(StringPtr buffer,int indentLevel) const{
void BaseField::toString(StringBuilder buffer,int indentLevel) const{
newLine(buffer,indentLevel);
*buffer += "field ";
*buffer += fieldName.c_str();
@@ -66,26 +65,26 @@ namespace epics { namespace pvData {
class BaseScalar: private BaseField,public Scalar {
public:
BaseScalar(StringConstPtr fieldName,ScalarType scalarType);
BaseScalar(StringConst fieldName,ScalarType scalarType);
virtual ~BaseScalar();
virtual void incReferenceCount() const {BaseField::incReferenceCount();}
virtual void decReferenceCount() const {BaseField::decReferenceCount();}
virtual int getReferenceCount() const {return BaseField::getReferenceCount();}
virtual StringConstPtr getFieldName() const{ return BaseField::getFieldName(); }
virtual StringConst getFieldName() const{ return BaseField::getFieldName(); }
virtual Type getType() const{return BaseField::getType();}
virtual ScalarType getScalarType() const { return scalarType;}
virtual void toString(StringPtr buf) const {toString(buf,0);}
virtual void toString(StringPtr buf,int indentLevel) const;
virtual void toString(StringBuilder buf) const {toString(buf,0);}
virtual void toString(StringBuilder buf,int indentLevel) const;
private:
ScalarType scalarType;
};
BaseScalar::BaseScalar(StringConstPtr fieldName,ScalarType scalarType)
BaseScalar::BaseScalar(StringConst fieldName,ScalarType scalarType)
: BaseField(fieldName,scalar),scalarType(scalarType){}
BaseScalar::~BaseScalar() {}
void BaseScalar::toString(StringPtr buffer,int indentLevel) const{
void BaseScalar::toString(StringBuilder buffer,int indentLevel) const{
BaseField::toString(buffer,indentLevel);
*buffer += " scalarType ";
ScalarTypeFunc::toString(buffer,scalarType);
@@ -95,27 +94,27 @@ namespace epics { namespace pvData {
class BaseScalarArray: private BaseField,public ScalarArray {
public:
BaseScalarArray(StringConstPtr fieldName,ScalarType elementType);
BaseScalarArray(StringConst fieldName,ScalarType elementType);
virtual ~BaseScalarArray();
virtual void incReferenceCount() const {BaseField::incReferenceCount();}
virtual void decReferenceCount() const {BaseField::decReferenceCount();}
virtual int getReferenceCount() const {return BaseField::getReferenceCount();}
virtual StringConstPtr getFieldName() const{ return BaseField::getFieldName(); }
virtual StringConst getFieldName() const{ return BaseField::getFieldName(); }
virtual Type getType() const{return BaseField::getType();}
virtual ScalarType getElementType() const { return elementType;}
virtual void toString(StringPtr buf) const {toString(buf,0);}
virtual void toString(StringPtr buf,int indentLevel) const;
virtual void toString(StringBuilder buf) const {toString(buf,0);}
virtual void toString(StringBuilder buf,int indentLevel) const;
private:
ScalarType elementType;
};
BaseScalarArray::BaseScalarArray
(StringConstPtr fieldName,ScalarType elementType)
(StringConst fieldName,ScalarType elementType)
: BaseField(fieldName,scalar),elementType(elementType){}
BaseScalarArray::~BaseScalarArray() {}
void BaseScalarArray::toString(StringPtr buffer,int indentLevel) const{
void BaseScalarArray::toString(StringBuilder buffer,int indentLevel) const{
BaseField::toString(buffer,indentLevel);
*buffer += " elementType ";
ScalarTypeFunc::toString(buffer,elementType);
@@ -125,39 +124,39 @@ namespace epics { namespace pvData {
class BaseStructure: private BaseField,public Structure {
public:
BaseStructure(StringConstPtr fieldName, int numberFields,FieldConstPtrArray fields);
BaseStructure(StringConst fieldName, int numberFields,FieldConstPtrArray fields);
virtual ~BaseStructure();
virtual void incReferenceCount() const {BaseField::incReferenceCount();}
virtual void decReferenceCount() const {BaseField::decReferenceCount();}
virtual int getReferenceCount() const {return BaseField::getReferenceCount();}
virtual StringConstPtr getFieldName() const{ return BaseField::getFieldName(); }
virtual StringConst getFieldName() const{ return BaseField::getFieldName(); }
virtual Type getType() const{return BaseField::getType();}
virtual int const getNumberFields() const {return numberFields;}
virtual FieldConstPtr getField(StringConstPtr fieldName) const;
virtual int getFieldIndex(StringConstPtr fieldName) const;
virtual FieldConstPtr getField(StringConst fieldName) const;
virtual int getFieldIndex(StringConst 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;
virtual void toString(StringBuilder buf) const {toString(buf,0);}
virtual void toString(StringBuilder buf,int indentLevel) const;
private:
int numberFields;
FieldConstPtrArray fields;
};
BaseStructure::BaseStructure (StringConstPtr fieldName,
BaseStructure::BaseStructure (StringConst fieldName,
int numberFields, FieldConstPtrArray fields)
: BaseField(fieldName,structure),
numberFields(numberFields),
fields(fields)
{
for(int i=0; i<numberFields; i++) {
StringConstPtr name = fields[i]->getFieldName();
StringConst name = fields[i]->getFieldName();
// look for duplicates
for(int j=i+1; j<numberFields; j++) {
StringConstPtr otherName = fields[j]->getFieldName();
int result = name->compare(*otherName);
StringConst otherName = fields[j]->getFieldName();
int result = name.compare(otherName);
if(result==0) {
std::string message("duplicate fieldName ");
message += *name;
String message("duplicate fieldName ");
message += name;
throw std::invalid_argument(message);
}
}
@@ -166,32 +165,32 @@ namespace epics { namespace pvData {
}
}
BaseStructure::~BaseStructure() {
if(debugLevel==highDebug) printf("~BaseStructure %s\n",BaseField::getFieldName()->c_str());
if(debugLevel==highDebug) printf("~BaseStructure %s\n",BaseField::getFieldName().c_str());
for(int i=0; i<numberFields; i++) {
FieldConstPtr pfield = fields[i];
pfield->decReferenceCount();
}
}
FieldConstPtr BaseStructure::getField(StringConstPtr fieldName) const {
FieldConstPtr BaseStructure::getField(StringConst fieldName) const {
for(int i=0; i<numberFields; i++) {
FieldConstPtr pfield = fields[i];
int result = fieldName->compare(*pfield->getFieldName());
int result = fieldName.compare(pfield->getFieldName());
if(result==0) return pfield;
}
return 0;
}
int BaseStructure::getFieldIndex(StringConstPtr fieldName) const {
int BaseStructure::getFieldIndex(StringConst fieldName) const {
for(int i=0; i<numberFields; i++) {
FieldConstPtr pfield = fields[i];
int result = fieldName->compare(*pfield->getFieldName());
int result = fieldName.compare(pfield->getFieldName());
if(result==0) return i;
}
return -1;
}
void BaseStructure::toString(StringPtr buffer,int indentLevel) const{
void BaseStructure::toString(StringBuilder buffer,int indentLevel) const{
BaseField::toString(buffer,indentLevel);
*buffer += " {";
for(int i=0; i<numberFields; i++) {
@@ -206,23 +205,23 @@ namespace epics { namespace pvData {
class BaseStructureArray: private BaseField,public StructureArray {
public:
BaseStructureArray(StringConstPtr fieldName,StructureConstPtr structure);
BaseStructureArray(StringConst fieldName,StructureConstPtr structure);
virtual ~BaseStructureArray();
virtual void incReferenceCount() const {BaseField::incReferenceCount();}
virtual void decReferenceCount() const {BaseField::decReferenceCount();}
virtual int getReferenceCount() const {return BaseField::getReferenceCount();}
virtual StringConstPtr getFieldName() const{
virtual StringConst 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;
virtual void toString(StringBuilder buf) const {toString(buf,0);}
virtual void toString(StringBuilder buf,int indentLevel) const;
private:
StructureConstPtr pstructure;
};
BaseStructureArray::BaseStructureArray(StringConstPtr fieldName,StructureConstPtr structure)
BaseStructureArray::BaseStructureArray(StringConst fieldName,StructureConstPtr structure)
: BaseField(fieldName,structureArray),pstructure(structure)
{
pstructure->incReferenceCount();
@@ -234,7 +233,7 @@ namespace epics { namespace pvData {
}
void BaseStructureArray::toString(StringPtr buffer,int indentLevel) const {
void BaseStructureArray::toString(StringBuilder buffer,int indentLevel) const {
BaseField::toString(buffer,indentLevel);
*buffer += " structure ";
pstructure->toString(buffer,indentLevel + 1);
@@ -242,7 +241,7 @@ namespace epics { namespace pvData {
FieldCreate::FieldCreate(){};
ScalarConstPtr FieldCreate::createScalar(StringConstPtr fieldName,
ScalarConstPtr FieldCreate::createScalar(StringConst fieldName,
ScalarType scalarType) const
{
BaseScalar *baseScalar = new BaseScalar(fieldName,scalarType);
@@ -250,13 +249,13 @@ namespace epics { namespace pvData {
}
ScalarArrayConstPtr FieldCreate::createScalarArray(
StringConstPtr fieldName,ScalarType elementType) const
StringConst fieldName,ScalarType elementType) const
{
BaseScalarArray *baseScalarArray = new BaseScalarArray(fieldName,elementType);
return baseScalarArray;
}
StructureConstPtr FieldCreate::createStructure (
StringConstPtr fieldName,int numberFields,
StringConst fieldName,int numberFields,
FieldConstPtr fields[]) const
{
BaseStructure *baseStructure = new BaseStructure(
@@ -264,13 +263,13 @@ namespace epics { namespace pvData {
return baseStructure;
}
StructureArrayConstPtr FieldCreate::createStructureArray(
StringConstPtr fieldName,StructureConstPtr structure) const
StringConst fieldName,StructureConstPtr structure) const
{
BaseStructureArray *baseStructureArray = new BaseStructureArray(fieldName,structure);
return baseStructureArray;
}
FieldConstPtr FieldCreate::create(StringConstPtr fieldName,
FieldConstPtr FieldCreate::create(StringConst fieldName,
FieldConstPtr pfield) const
{
Type type = pfield->getType();
@@ -292,8 +291,8 @@ namespace epics { namespace pvData {
return createStructureArray(fieldName,pstructureArray->getStructure());
}
}
std::string message("field ");
message += *fieldName;
String message("field ");
message += fieldName;
throw std::logic_error(message);
}
@@ -306,10 +305,10 @@ namespace epics { namespace pvData {
};
FieldCreate * getFieldCreate() {
static epicsMutex *lock = new epicsMutex();
lock->lock();
static Mutex *mutex = new Mutex();
Lock xx(mutex);
if(instance==0) instance = new FieldCreateExt();
lock->unlock();
return instance;
}

29
pvDataApp/factory/PVAuxInfoImpl.cpp
View File

@@ -3,6 +3,7 @@
#include <cstdlib>
#include <string>
#include <cstdio>
#include "noDefaultMethods.h"
#include "pvData.h"
#include "factory.h"
@@ -14,10 +15,10 @@ namespace epics { namespace pvData {
public:
PVAuxInfoPvt(PVField *pvField)
: pvField(pvField),
theMap(std::map<StringConstPtr, PVScalar * >())
theMap(std::map<StringConst, PVScalar * >())
{}
PVField *pvField;
std::map<StringConstPtr, PVScalar * > theMap;
std::map<StringConst, PVScalar * > theMap;
};
PVAuxInfo::PVAuxInfo(PVField *pvField)
@@ -34,49 +35,49 @@ namespace epics { namespace pvData {
return pImpl->pvField;
}
typedef std::map<StringConstPtr,PVScalar * >::const_iterator map_iterator;
typedef std::map<StringConst,PVScalar * >::const_iterator map_iterator;
PVScalar * PVAuxInfo::createInfo(StringConstPtr key,ScalarType scalarType)
PVScalar * PVAuxInfo::createInfo(StringConst key,ScalarType scalarType)
{
map_iterator i = pImpl->theMap.find(key);
if(i!=pImpl->theMap.end()) {
std::string message("AuxoInfo:create key ");
message += key->c_str();
String message("AuxoInfo:create key ");
message += key.c_str();
message += " already exists with scalarType ";
ScalarTypeFunc::toString(&message,scalarType);
pImpl->pvField->message(&message,errorMessage);
pImpl->pvField->message(message,errorMessage);
}
PVScalar *pvScalar = pvDataCreate->createPVScalar(0,key,scalarType);
pImpl->theMap.insert(std::pair<StringConstPtr,PVScalar * >(key, pvScalar));
pImpl->theMap.insert(std::pair<StringConst,PVScalar * >(key, pvScalar));
return pvScalar;
}
std::map<StringConstPtr, PVScalar * > *PVAuxInfo::getInfos()
std::map<StringConst, PVScalar * > *PVAuxInfo::getInfos()
{
return &pImpl->theMap;
}
PVScalar * PVAuxInfo::getInfo(StringConstPtr key)
PVScalar * PVAuxInfo::getInfo(StringConst key)
{
map_iterator i = pImpl->theMap.find(key);
if(i!=pImpl->theMap.end()) return i->second;
return 0;
}
void PVAuxInfo::toString(StringPtr buf)
void PVAuxInfo::toString(StringBuilder buf)
{
return PVAuxInfo::toString(buf,0);
}
void PVAuxInfo::toString(StringPtr buf,int indentLevel)
void PVAuxInfo::toString(StringBuilder buf,int indentLevel)
{
map_iterator i = pImpl->theMap.begin();
while(i!=pImpl->theMap.end()) {
StringConstPtr key = i->first;
StringConst key = i->first;
PVScalar *value = i->second;
*buf += " ";
*buf += key->c_str();
*buf += key.c_str();
*buf += " ";
value->toString(buf);
}

30
pvDataApp/factory/PVDataCreateFactory.cpp
View File

@@ -3,7 +3,7 @@
#include <cstdlib>
#include <string>
#include <cstdio>
#include <epicsMutex.h>
#include <lock.h>
#include "pvData.h"
#include "convert.h"
#include "factory.h"
@@ -40,12 +40,12 @@ namespace epics { namespace pvData {
return createPVStructureArray(parent,
(StructureArrayConstPtr)field);
}
std::string message("PVDataCreate::createPVField");
String message("PVDataCreate::createPVField");
throw std::invalid_argument(message);
};
PVField *PVDataCreate::createPVField(PVStructure *parent,
StringConstPtr fieldName,PVField * fieldToClone)
StringConst fieldName,PVField * fieldToClone)
{
switch(fieldToClone->getField()->getType()) {
case scalar:
@@ -57,11 +57,11 @@ namespace epics { namespace pvData {
return (PVField *)createPVStructure(parent,fieldName,
(PVStructure *)fieldToClone);
case structureArray:
std::string message(
String message(
"PVDataCreate::createPVField structureArray not valid fieldToClone");
throw std::invalid_argument(message);
}
std::string message("PVDataCreate::createPVField");
String message("PVDataCreate::createPVField");
throw std::logic_error(message);
};
@@ -78,7 +78,7 @@ namespace epics { namespace pvData {
};
PVScalar *PVDataCreate::createPVScalar(PVStructure *parent,
StringConstPtr fieldName,ScalarType scalarType)
StringConst fieldName,ScalarType scalarType)
{
if(fieldCreate==0) fieldCreate = getFieldCreate();
ScalarConstPtr scalar = fieldCreate->createScalar(fieldName,scalarType);
@@ -86,7 +86,7 @@ namespace epics { namespace pvData {
};
PVScalar *PVDataCreate::createPVScalar(PVStructure *parent,
StringConstPtr fieldName,PVScalar * scalarToClone)
StringConst fieldName,PVScalar * scalarToClone)
{
PVScalar *pvScalar = createPVScalar(parent,fieldName,
scalarToClone->getScalar()->getScalarType());
@@ -114,13 +114,13 @@ namespace epics { namespace pvData {
};
PVScalarArray *PVDataCreate::createPVScalarArray(PVStructure *parent,
StringConstPtr fieldName,ScalarType elementType)
StringConst fieldName,ScalarType elementType)
{
throw std::logic_error(notImplemented);
};
PVScalarArray *PVDataCreate::createPVScalarArray(PVStructure *parent,
StringConstPtr fieldName,PVScalarArray * scalarArrayToClone)
StringConst fieldName,PVScalarArray * scalarArrayToClone)
{
throw std::logic_error(notImplemented);
};
@@ -138,13 +138,13 @@ namespace epics { namespace pvData {
};
PVStructure *PVDataCreate::createPVStructure(PVStructure *parent,
StringConstPtr fieldName,FieldConstPtrArray fields)
StringConst fieldName,FieldConstPtrArray fields)
{
throw std::logic_error(notImplemented);
};
PVStructure *PVDataCreate::createPVStructure(PVStructure *parent,
StringConstPtr fieldName,PVStructure *structToClone)
StringConst fieldName,PVStructure *structToClone)
{
throw std::logic_error(notImplemented);
};
@@ -156,10 +156,10 @@ namespace epics { namespace pvData {
};
PVDataCreate * getPVDataCreate() {
static epicsMutex *lock = new epicsMutex();
lock->lock();
if(pvDataCreate==0) pvDataCreate = new PVDataCreateExt();
lock->unlock();
static Mutex *mutex = new Mutex();
Lock xx(mutex);
if(pvDataCreate==0) pvDataCreate = new PVDataCreateExt();
return pvDataCreate;
}

28
pvDataApp/factory/TypeFunc.cpp
View File

@@ -8,8 +8,8 @@
namespace epics { namespace pvData {
void TypeFunc::toString(StringPtr buf,const Type type) {
static const std::string unknownString = "logic error unknown Type";
void TypeFunc::toString(StringBuilder buf,const Type type) {
static StringConst unknownString = "logic error unknown Type";
switch(type) {
case scalar : *buf += "scalar"; break;
case scalarArray : *buf += "scalarArray"; break;
@@ -36,20 +36,20 @@ namespace epics { namespace pvData {
return false;
}
ScalarType ScalarTypeFunc::getScalarType(StringConstPtr 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;
ScalarType ScalarTypeFunc::getScalarType(StringConst pvalue) {
static StringConst 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(StringPtr buf,const ScalarType scalarType) {
static const std::string unknownString = "logic error unknown ScalarType";
void ScalarTypeFunc::toString(StringBuilder buf,const ScalarType scalarType) {
static StringConst unknownString = "logic error unknown ScalarType";
switch(scalarType) {
case pvBoolean : *buf += "pvBoolean"; return;
case pvByte : *buf += "pvByte"; return;;

2
pvDataApp/factory/factory.h
View File

@@ -6,7 +6,5 @@ namespace epics { namespace pvData {
enum DebugLevel{noDebug,lowDebug,highDebug};
static DebugLevel debugLevel = highDebug;
}}
#endif /*FACTORY_H */

2
pvDataApp/misc/Makefile
View File

@@ -2,6 +2,8 @@ TOP=../..
include $(TOP)/configure/CONFIG
INC += noDefaultMethods.h
INC += lock.h
INC += requester.h
INC += serialize.h
INC += bitSet.h

1
pvDataApp/misc/bitSet.h
View File

@@ -1,7 +1,6 @@
/* bitSet.h */
#ifndef BITSET_H
#define BITSET_H
#include "pvIntrospect.h"
namespace epics { namespace pvData {
class BitSet;

5
pvDataApp/misc/byteBuffer.h
View File

@@ -3,7 +3,6 @@
#ifndef BYTEBUFFER_H
#define BYTEBUFFER_H
#include "epicsTypes.h"
#include "pvIntrospect.h"
namespace epics { namespace pvData {
// not sure why I have to define epicsInt64
@@ -21,7 +20,7 @@ class ByteBuffer {
virtual epicsInt64 getLong() const = 0;
virtual float getFloat() const = 0;
virtual double getDouble() const = 0;
virtual StringConstPtr getString() const = 0;
virtual StringConst getString() const = 0;
virtual ByteBuffer * putBoolean(epicsBoolean value) const = 0;
virtual ByteBuffer * putByte(epicsInt8 value) const = 0;
virtual ByteBuffer * geShort(epicsInt16 value) const = 0;
@@ -29,7 +28,7 @@ class ByteBuffer {
virtual ByteBuffer * putLong(epicsInt64 value) const = 0;
virtual ByteBuffer * putFloat(float value) const = 0;
virtual ByteBuffer * putDouble(double value) const = 0;
virtual ByteBuffer * putString(StringConstPtr value) const = 0;
virtual ByteBuffer * putString(StringConst value) const = 0;
// Must define arrays
};

32
pvDataApp/misc/lock.h Normal file
View File

@@ -0,0 +1,32 @@
/* lock.h */
#ifndef LOCK_H
#define LOCK_H
#include <epicsMutex.h>
#include "noDefaultMethods.h"
/* This is based on item 14 of
* Effective C++, Third Edition, Scott Meyers
*/
namespace epics { namespace pvData {
class Mutex {
public:
Mutex() : lockPtr(new epicsMutex()){}
~Mutex() { delete lockPtr;};
void lock(){lockPtr->lock();}\
void unlock(){lockPtr->unlock();}
private:
epicsMutex *lockPtr;
};
class Lock : private NoDefaultMethods {
public:
explicit Lock(Mutex *pm)
: mutexPtr(pm)
{mutexPtr->lock();}
~Lock(){mutexPtr->unlock();}
private:
Mutex *mutexPtr;
};
}}
#endif /* LOCK_H */

22
pvDataApp/misc/noDefaultMethods.h Normal file
View File

@@ -0,0 +1,22 @@
/* noDefaultMethods.h */
#ifndef NO_DEFAULT_METHODS_H
#define NO_DEFAULT_METHODS_H
namespace epics { namespace pvData {
/* This is based on Item 6 of
* Effective C++, Third Edition, Scott Meyers
*/
class NoDefaultMethods {
protected:
// allow by derived objects
NoDefaultMethods(){};
~NoDefaultMethods(){}
private:
// do not implment
NoDefaultMethods(const NoDefaultMethods&);
NoDefaultMethods & operator=(const NoDefaultMethods &);
};
}}
#endif /* NO_DEFAULT_METHODS_H */

5
pvDataApp/misc/requester.h
View File

@@ -2,7 +2,6 @@
#include <string>
#ifndef REQUESTER_H
#define REQUESTER_H
#include "pvIntrospect.h"
namespace epics { namespace pvData {
enum MessageType {infoMessage,warningMessage,errorMessage,fatalErrorMessage};
@@ -11,8 +10,8 @@ namespace epics { namespace pvData {
class Requester {
public:
virtual StringConstPtr getRequesterName() const = 0;
virtual void message(StringConstPtr message,MessageType messageType) const = 0;
virtual StringConst getRequesterName() const = 0;
virtual void message(StringConst message,MessageType messageType) const = 0;
};
}}
#endif /* REQUESTER_H */

16
pvDataApp/pv/convert.h
View File

@@ -12,15 +12,15 @@ namespace epics { namespace pvData {
public:
Convert();
~Convert();
void getFullName(StringConstPtr buf,PVField const *pvField);
void getString(StringPtr buf,PVField const * pvField,int indentLevel);
void getString(StringPtr buf,PVField const * pvField);
void fromString(PVScalar *pv, StringConstPtr from);
int fromString(PVScalarArray *pv, StringConstPtr from);
void getFullName(StringConst buf,PVField const *pvField);
void getString(StringBuilder buf,PVField const * pvField,int indentLevel);
void getString(StringBuilder buf,PVField const * pvField);
void fromString(PVScalar *pv, StringConst from);
int fromString(PVScalarArray *pv, StringConst from);
int fromStringArray(PVScalarArray *pv, int offset, int length,
StringPtrArray from, int fromOffset);
StringConstArray from, int fromOffset);
int toStringArray(PVScalarArray const *pv, int offset, int length,
StringPtrArray to, int fromOffset);
StringConstArray to, int fromOffset);
epicsBoolean isCopyCompatible(FieldConstPtr from, FieldConstPtr to);
void copy(PVField const *from,PVField *to);
epicsBoolean isCopyScalarCompatible(
@@ -73,7 +73,7 @@ namespace epics { namespace pvData {
float from[], int fromOffset);
int fromDoubleArray(PVScalarArray *pv, int offset, int length,
double from[], int fromOffset);
void newLine(StringPtr buf, int indentLevel);
void newLine(StringBuilder buf, int indentLevel);
private:
Convert(Convert const & ); // not implemented

198
pvDataApp/pv/pvData.h
View File

@@ -5,6 +5,7 @@
#ifndef PVDATA_H
#define PVDATA_H
#include "pvIntrospect.h"
#include "noDefaultMethods.h"
#include "requester.h"
#include "byteBuffer.h"
#include "serialize.h"
@@ -34,21 +35,20 @@ namespace epics { namespace pvData {
class PVStructure;
class PVStructureArray;
class PVAuxInfo {
// NOTE this prevents compiler from generating default methods for this and
// derived classes
class PVAuxInfo : private NoDefaultMethods {
public:
PVAuxInfo(PVField *pvField);
~PVAuxInfo();
PVField * getPVField();
PVScalar * createInfo(StringConstPtr key,ScalarType scalarType);
std::map<StringConstPtr, PVScalar * > *getInfos();
PVScalar * getInfo(StringConstPtr key);
void toString(StringPtr buf);
void toString(StringPtr buf,int indentLevel);
PVScalar * createInfo(StringConst key,ScalarType scalarType);
std::map<StringConst, PVScalar * > *getInfos();
PVScalar * getInfo(StringConst key);
void toString(StringBuilder buf);
void toString(StringBuilder buf,int indentLevel);
private:
static void init();
PVAuxInfo(); // not implemented
PVAuxInfo(PVAuxInfo const & ); // not implemented
PVAuxInfo & operator=(PVAuxInfo const &); //not implemented
class PVAuxInfoPvt *pImpl;
};
@@ -56,11 +56,11 @@ namespace epics { namespace pvData {
virtual void postPut() = 0;
};
class PVField : public Requester, public Serializable {
class PVField : public Requester, public Serializable ,private NoDefaultMethods{
public:
virtual ~PVField();
StringConstPtr getRequesterName() const;
virtual void message(StringConstPtr message,MessageType messageType) const;
StringConst getRequesterName() const;
virtual void message(StringConst message,MessageType messageType) const;
virtual void setRequester(Requester *prequester);
int getFieldOffset() const;
int getNextFieldOffset() const;
@@ -71,18 +71,15 @@ namespace epics { namespace pvData {
FieldConstPtr getField() const;
PVStructure * getParent() const;
void replacePVField(PVField * newPVField);
void renameField(StringConstPtr newName);
void renameField(StringConst newName);
void postPut() const;
void setPostHandler(PostHandler *postHandler);
virtual void toString(StringPtr buf) const;
virtual void toString(StringPtr buf,int indentLevel) const;
virtual void toString(StringBuilder buf) const;
virtual void toString(StringBuilder buf,int indentLevel) const;
protected:
PVField(PVStructure *parent,FieldConstPtr field);
void replaceStructure();
private:
PVField();//not implemented
PVField(PVField const & ); // not implemented
PVField & operator=(PVField const &); //not implemented
class PVFieldPvt *pImpl;
static void computeOffset(const PVField * const pvField);
static void computeOffset(const PVField * const pvField,int offset);
@@ -92,14 +89,10 @@ namespace epics { namespace pvData {
public:
virtual ~PVScalar();
ScalarConstPtr getScalar() const;
virtual void toString(StringPtr buf) const = 0;
virtual void toString(StringPtr buf,int indentLevel) const = 0;
virtual void toString(StringBuilder buf) const = 0;
virtual void toString(StringBuilder buf,int indentLevel) const = 0;
protected:
PVScalar(PVStructure *parent,ScalarConstPtr scalar);
private:
PVScalar(); // not implemented
PVScalar(PVScalar const & ); // not implemented
PVScalar & operator=(PVScalar const &); //not implemented
};
class PVArray : public PVField, public SerializableArray {
@@ -117,14 +110,11 @@ namespace epics { namespace pvData {
DeserializableControl *pflusher) = 0;
virtual void serialize(ByteBuffer *pbuffer,
SerializableControl *pflusher, int offset, int count) const = 0;
virtual void toString(StringPtr buf) const;
virtual void toString(StringPtr buf,int indentLevel) const = 0;
virtual void toString(StringBuilder buf) const;
virtual void toString(StringBuilder buf,int indentLevel) const = 0;
protected:
PVArray(PVStructure *parent,FieldConstPtr field);
private:
PVArray(); // not implemented
PVArray(PVArray const & ); // not implemented
PVArray & operator=(PVArray const &); //not implemented
class PVArrayPvt *pImpl;
};
@@ -140,14 +130,11 @@ namespace epics { namespace pvData {
DeserializableControl *pflusher) = 0;
virtual void serialize(ByteBuffer *pbuffer,
SerializableControl *pflusher, int offset, int count) const = 0;
virtual void toString(StringPtr buf) const = 0;
virtual void toString(StringPtr buf,int indentLevel) const = 0;
virtual void toString(StringBuilder buf) const = 0;
virtual void toString(StringBuilder buf,int indentLevel) const = 0;
protected:
PVScalarArray(PVStructure *parent,ScalarArrayConstPtr scalarArray);
private:
PVScalarArray(); // not implemented
PVScalarArray(PVScalarArray const & ); // not implemented
PVScalarArray & operator=(PVScalarArray const &); //not implemented
};
typedef PVStructure * PVStructurePtr;
@@ -174,8 +161,8 @@ namespace epics { namespace pvData {
DeserializableControl *pflusher);
virtual void serialize(ByteBuffer *pbuffer,
SerializableControl *pflusher, int offset, int count) const;
virtual void toString(StringPtr buf) const;
virtual void toString(StringPtr buf,int indentLevel) const;
virtual void toString(StringBuilder buf) const;
virtual void toString(StringBuilder buf,int indentLevel) const;
protected:
PVStructureArray(PVStructure *parent,
StructureArrayConstPtr structureArray);
@@ -189,33 +176,33 @@ namespace epics { namespace pvData {
typedef PVField * PVFieldPtr;
typedef PVFieldPtr * PVFieldArrayPtr;
class PVStructure : public PVField, public BitSetSerializable {
class PVStructure : public PVField,public BitSetSerializable {
public:
virtual ~PVStructure();
StructureConstPtr getStructure();
PVFieldArrayPtr getPVFields();
PVFieldPtr getSubField(StringConstPtr fieldName);
PVFieldPtr getSubField(StringConst fieldName);
PVFieldPtr getSubField(int fieldOffset);
void appendPVField(PVField * pvField);
void appendPVFields(PVFieldArrayPtr pvFields);
void removePVField(StringConstPtr fieldName);
PVBoolean *getBooleanField(StringConstPtr fieldName);
PVByte *getByteField(StringConstPtr fieldName);
PVShort *getShortField(StringConstPtr fieldName);
PVInt *getIntField(StringConstPtr fieldName);
PVLong *getLongField(StringConstPtr fieldName);
PVFloat *getFloatField(StringConstPtr fieldName);
PVDouble *getDoubleField(StringConstPtr fieldName);
PVString *getStringField(StringConstPtr fieldName);
PVStructure *getStructureField(StringConstPtr fieldName);
void removePVField(StringConst fieldName);
PVBoolean *getBooleanField(StringConst fieldName);
PVByte *getByteField(StringConst fieldName);
PVShort *getShortField(StringConst fieldName);
PVInt *getIntField(StringConst fieldName);
PVLong *getLongField(StringConst fieldName);
PVFloat *getFloatField(StringConst fieldName);
PVDouble *getDoubleField(StringConst fieldName);
PVString *getStringField(StringConst fieldName);
PVStructure *getStructureField(StringConst fieldName);
PVScalarArray *getScalarArrayField(
StringConstPtr fieldName,ScalarType elementType);
PVStructureArray *getStructureArrayField(StringConstPtr fieldName);
StringConstPtr getExtendsStructureName();
StringConst fieldName,ScalarType elementType);
PVStructureArray *getStructureArrayField(StringConst fieldName);
StringConst getExtendsStructureName();
epicsBoolean putExtendsStructureName(
StringConstPtr extendsStructureName);
virtual void toString(StringPtr buf) const;
virtual void toString(StringPtr buf,int indentLevel) const;
StringConst extendsStructureName);
virtual void toString(StringBuilder buf) const;
virtual void toString(StringBuilder buf,int indentLevel) const;
virtual void serialize(
ByteBuffer *pbuffer,SerializableControl *pflusher) const;
virtual void deserialize(
@@ -229,9 +216,6 @@ namespace epics { namespace pvData {
protected:
PVStructure(PVStructure *parent,StructureConstPtr structure);
private:
PVStructure(); // not implemented
PVStructure(PVStructure const & ); // not implemented
PVStructure& operator=(PVStructure const &); //not implemented
class PVStructurePvt *pImpl;
};
@@ -244,9 +228,6 @@ namespace epics { namespace pvData {
PVBoolean(PVStructure *parent,ScalarConstPtr scalar)
: PVScalar(parent,scalar) {}
private:
PVBoolean(); // not implemented
PVBoolean(PVBoolean const & ); // not implemented
PVBoolean & operator=(PVBoolean const &); //not implemented
};
class PVByte : public PVScalar {
@@ -258,9 +239,6 @@ namespace epics { namespace pvData {
PVByte(PVStructure *parent,ScalarConstPtr scalar)
: PVScalar(parent,scalar) {}
private:
PVByte(); // not implemented
PVByte(PVByte const & ); // not implemented
PVByte & operator=(PVByte const &); //not implemented
};
class PVShort : public PVScalar {
@@ -272,12 +250,9 @@ namespace epics { namespace pvData {
PVShort(PVStructure *parent,ScalarConstPtr scalar)
: PVScalar(parent,scalar) {}
private:
PVShort(); // not implemented
PVShort(PVShort const & ); // not implemented
PVShort & operator=(PVShort const &); //not implemented
};
class PVInt : public PVScalar {
class PVInt : public PVScalar{
public:
virtual ~PVInt();
virtual epicsInt32 get() const = 0;
@@ -286,9 +261,6 @@ namespace epics { namespace pvData {
PVInt(PVStructure *parent,ScalarConstPtr scalar)
: PVScalar(parent,scalar) {}
private:
PVInt(); // not implemented
PVInt(PVInt const & ); // not implemented
PVInt & operator=(PVInt const &); //not implemented
};
class PVLong : public PVScalar {
@@ -300,9 +272,6 @@ namespace epics { namespace pvData {
PVLong(PVStructure *parent,ScalarConstPtr scalar)
: PVScalar(parent,scalar) {}
private:
PVLong(); // not implemented
PVLong(PVLong const & ); // not implemented
PVLong & operator=(PVLong const &); //not implemented
};
class PVFloat : public PVScalar {
@@ -314,9 +283,6 @@ namespace epics { namespace pvData {
PVFloat(PVStructure *parent,ScalarConstPtr scalar)
: PVScalar(parent,scalar) {}
private:
PVFloat(); // not implemented
PVFloat(PVFloat const & ); // not implemented
PVFloat & operator=(PVFloat const &); //not implemented
};
class PVDouble : public PVScalar {
@@ -328,23 +294,17 @@ namespace epics { namespace pvData {
PVDouble(PVStructure *parent,ScalarConstPtr scalar)
: PVScalar(parent,scalar) {}
private:
PVDouble(); // not implemented
PVDouble(PVScalar const & ); // not implemented
PVDouble & operator=(PVScalar const &); //not implemented
};
class PVString : public PVScalar {
public:
virtual ~PVString();
virtual StringConstPtr get() const = 0;
virtual void put(StringConstPtr value) = 0;
virtual StringConst get() const = 0;
virtual void put(StringConst value) = 0;
protected:
PVString(PVStructure *parent,ScalarConstPtr scalar)
: PVScalar(parent,scalar) {}
private:
PVString(); // not implemented
PVString(PVString const & ); // not implemented
PVString & operator=(PVString const &); //not implemented
};
typedef epicsBoolean * EpicsBooleanArrayPtr;
@@ -358,8 +318,8 @@ namespace epics { namespace pvData {
class PVBooleanArray : public PVScalarArray {
public:
virtual ~PVBooleanArray();
virtual void toString(StringPtr buf) const;
virtual void toString(StringPtr buf,int indentLevel) const;
virtual void toString(StringBuilder buf) const;
virtual void toString(StringBuilder buf,int indentLevel) const;
virtual int get(int offset, int length, BooleanArrayData *data) const;
virtual int put(int offset,int length, EpicsBooleanArrayPtr from, int fromOffset);
virtual void shareData(EpicsBooleanArrayPtr from);
@@ -368,9 +328,6 @@ namespace epics { namespace pvData {
protected:
PVBooleanArray(PVStructure *parent,ScalarConstPtr scalar);
private:
PVBooleanArray(); // not implemented
PVBooleanArray(PVBooleanArray const & ); // not implemented
PVBooleanArray & operator=(PVBooleanArray const &); //not implemented
};
typedef signed char * ByteArrayPtr;
@@ -384,8 +341,8 @@ namespace epics { namespace pvData {
class PVByteArray : public PVScalarArray {
public:
virtual ~PVByteArray();
virtual void toString(StringPtr buf) const;
virtual void toString(StringPtr buf,int indentLevel) const;
virtual void toString(StringBuilder buf) const;
virtual void toString(StringBuilder buf,int indentLevel) const;
virtual int get(int offset, int length, ByteArrayData *data) const;
virtual int put(int offset,int length, ByteArrayPtr from, int fromOffset);
virtual void shareData(ByteArrayPtr from);
@@ -394,9 +351,6 @@ namespace epics { namespace pvData {
protected:
PVByteArray(PVStructure *parent,ScalarConstPtr scalar);
private:
PVByteArray(); // not implemented
PVByteArray(PVByteArray const & ); // not implemented
PVByteArray & operator=(PVByteArray const &); //not implemented
};
typedef short * ShortArrayPtr;
@@ -410,8 +364,8 @@ namespace epics { namespace pvData {
class PVShortArray : public PVScalarArray {
public:
virtual ~PVShortArray();
virtual void toString(StringPtr buf) const;
virtual void toString(StringPtr buf,int indentLevel) const;
virtual void toString(StringBuilder buf) const;
virtual void toString(StringBuilder buf,int indentLevel) const;
virtual int get(int offset, int length, ShortArrayData *data) const;
virtual int put(int offset,int length, ShortArrayPtr from, int fromOffset);
virtual void shareData(ShortArrayPtr from);
@@ -420,9 +374,6 @@ namespace epics { namespace pvData {
protected:
PVShortArray(PVStructure *parent,ScalarConstPtr scalar);
private:
PVShortArray(); // not implemented
PVShortArray(PVShortArray const & ); // not implemented
PVShortArray & operator=(PVShortArray const &); //not implemented
};
typedef int * IntArrayPtr;
@@ -436,8 +387,8 @@ namespace epics { namespace pvData {
class PVIntArray : public PVScalarArray {
public:
virtual ~PVIntArray();
virtual void toString(StringPtr buf) const;
virtual void toString(StringPtr buf,int indentLevel) const;
virtual void toString(StringBuilder buf) const;
virtual void toString(StringBuilder buf,int indentLevel) const;
virtual int get(int offset, int length, IntArrayData *data) const;
virtual int put(int offset,int length, IntArrayPtr from, int fromOffset);
virtual void shareData(IntArrayPtr from);
@@ -446,9 +397,6 @@ namespace epics { namespace pvData {
protected:
PVIntArray(PVStructure *parent,ScalarConstPtr scalar);
private:
PVIntArray(); // not implemented
PVIntArray(PVIntArray const & ); // not implemented
PVIntArray & operator=(PVIntArray const &); //not implemented
};
typedef long * LongArrayPtr;
@@ -462,8 +410,8 @@ namespace epics { namespace pvData {
class PVLongArray : public PVScalarArray {
public:
virtual ~PVLongArray();
virtual void toString(StringPtr buf) const;
virtual void toString(StringPtr buf,int indentLevel) const;
virtual void toString(StringBuilder buf) const;
virtual void toString(StringBuilder buf,int indentLevel) const;
virtual int get(int offset, int length, LongArrayData *data) const;
virtual int put(int offset,int length, LongArrayPtr from, int fromOffset);
virtual void shareData(LongArrayPtr from);
@@ -472,9 +420,6 @@ namespace epics { namespace pvData {
protected:
PVLongArray(PVStructure *parent,ScalarConstPtr scalar);
private:
PVLongArray(); // not implemented
PVLongArray(PVLongArray const & ); // not implemented
PVLongArray & operator=(PVLongArray const &); //not implemented
};
@@ -489,8 +434,8 @@ namespace epics { namespace pvData {
class PVFloatArray : public PVScalarArray {
public:
virtual ~PVFloatArray();
virtual void toString(StringPtr buf) const;
virtual void toString(StringPtr buf,int indentLevel) const;
virtual void toString(StringBuilder buf) const;
virtual void toString(StringBuilder buf,int indentLevel) const;
virtual int get(int offset, int length, FloatArrayData *data) const;
virtual int put(int offset,int length, FloatArrayPtr from, int fromOffset);
virtual void shareData(FloatArrayPtr from);
@@ -499,9 +444,6 @@ namespace epics { namespace pvData {
protected:
PVFloatArray(PVStructure *parent,ScalarConstPtr scalar);
private:
PVFloatArray(); // not implemented
PVFloatArray(PVFloatArray const & ); // not implemented
PVFloatArray & operator=(PVFloatArray const &); //not implemented
};
typedef double * DoubleArrayPtr;
@@ -515,8 +457,8 @@ namespace epics { namespace pvData {
class PVDoubleArray : public PVScalarArray {
public:
virtual ~PVDoubleArray();
virtual void toString(StringPtr buf) const = 0;
virtual void toString(StringPtr buf,int indentLevel) const = 0;
virtual void toString(StringBuilder buf) const = 0;
virtual void toString(StringBuilder buf,int indentLevel) const = 0;
virtual int get(int offset, int length, DoubleArrayData *data) const = 0;
virtual int put(int offset,int length, DoubleArrayPtr from, int fromOffset) = 0;
virtual void shareData(DoubleArrayPtr from) = 0;
@@ -525,9 +467,6 @@ namespace epics { namespace pvData {
protected:
PVDoubleArray(PVStructure *parent,ScalarArrayConstPtr scalar);
private:
PVDoubleArray(); // not implemented
PVDoubleArray(PVDoubleArray const & ); // not implemented
PVDoubleArray & operator=(PVDoubleArray const &); //not implemented
};
typedef std::string * StringArrayPtr;
@@ -541,8 +480,8 @@ namespace epics { namespace pvData {
class PVStringArray : public PVScalarArray {
public:
virtual ~PVStringArray();
virtual void toString(StringPtr buf) const;
virtual void toString(StringPtr buf,int indentLevel) const;
virtual void toString(StringBuilder buf) const;
virtual void toString(StringBuilder buf,int indentLevel) const;
virtual int get(int offset, int length, StringArrayData *data) const;
virtual int put(int offset,int length, StringArrayPtr from, int fromOffset);
virtual void shareData(StringArrayPtr from);
@@ -551,9 +490,6 @@ namespace epics { namespace pvData {
protected:
PVStringArray(PVStructure *parent,ScalarConstPtr scalar);
private:
PVStringArray(); // not implemented
PVStringArray(PVStringArray const & ); // not implemented
PVStringArray & operator=(PVStringArray const &); //not implemented
};
class PVDataCreate {
@@ -561,26 +497,26 @@ namespace epics { namespace pvData {
PVField *createPVField(PVStructure *parent,
FieldConstPtr field);
PVField *createPVField(PVStructure *parent,
StringConstPtr fieldName,PVField * fieldToClone);
StringConst fieldName,PVField * fieldToClone);
PVScalar *createPVScalar(PVStructure *parent,ScalarConstPtr scalar);
PVScalar *createPVScalar(PVStructure *parent,
StringConstPtr fieldName,ScalarType scalarType);
StringConst fieldName,ScalarType scalarType);
PVScalar *createPVScalar(PVStructure *parent,
StringConstPtr fieldName,PVScalar * scalarToClone);
StringConst fieldName,PVScalar * scalarToClone);
PVScalarArray *createPVScalarArray(PVStructure *parent,
ScalarArrayConstPtr scalarArray);
PVScalarArray *createPVScalarArray(PVStructure *parent,
StringConstPtr fieldName,ScalarType elementType);
StringConst fieldName,ScalarType elementType);
PVScalarArray *createPVScalarArray(PVStructure *parent,
StringConstPtr fieldName,PVScalarArray * scalarArrayToClone);
StringConst fieldName,PVScalarArray * scalarArrayToClone);
PVStructureArray *createPVStructureArray(PVStructure *parent,
StructureArrayConstPtr structureArray);
PVStructure *createPVStructure(PVStructure *parent,
StructureConstPtr structure);
PVStructure *createPVStructure(PVStructure *parent,
StringConstPtr fieldName,FieldConstPtrArray fields);
StringConst fieldName,FieldConstPtrArray fields);
PVStructure *createPVStructure(PVStructure *parent,
StringConstPtr fieldName,PVStructure *structToClone);
StringConst fieldName,PVStructure *structToClone);
protected:
PVDataCreate();
};

47
pvDataApp/pv/pvIntrospect.h
View File

@@ -3,6 +3,7 @@
#include <stdexcept>
#ifndef PVINTROSPECT_H
#define PVINTROSPECT_H
#include "noDefaultMethods.h"
namespace epics { namespace pvData {
class Field;
class Scalar;
@@ -10,12 +11,10 @@ namespace epics { namespace pvData {
class Structure;
class StructureArray;
typedef std::string * StringPtr;
typedef StringPtr * StringPtrArray;
// pointer to constant string
typedef std::string const * StringConstPtr;
//array of pointers to constant string
typedef StringConstPtr * StringConstPtrArray;
typedef std::string String;
typedef std::string * StringBuilder;
typedef std::string const StringConst;
typedef StringConst * StringConstArray;
typedef Field const * FieldConstPtr;
typedef FieldConstPtr * FieldConstPtrArray;
@@ -33,7 +32,7 @@ namespace epics { namespace pvData {
class TypeFunc {
public:
static void toString(StringPtr buf,const Type type);
static void toString(StringBuilder buf,const Type type);
};
enum ScalarType {
@@ -52,20 +51,24 @@ namespace epics { namespace pvData {
static bool isInteger(ScalarType type);
static bool isNumeric(ScalarType type);
static bool isPrimitive(ScalarType type);
static ScalarType getScalarType(StringConstPtr value);
static void toString(StringPtr buf,const ScalarType scalarType);
static ScalarType getScalarType(StringConst value);
static void toString(StringBuilder buf,const ScalarType scalarType);
};
class Field {
class Field : private NoDefaultMethods {
public:
virtual ~Field();
virtual int getReferenceCount() const = 0;
virtual StringConst getFieldName() const = 0;
virtual Type getType() const = 0;
virtual void toString(StringBuilder buf) const = 0;
virtual void toString(StringBuilder buf,int indentLevel) const = 0;
private:
virtual void incReferenceCount() const = 0;
virtual void decReferenceCount() const = 0;
virtual int getReferenceCount() const = 0;
virtual StringConstPtr getFieldName() const = 0;
virtual Type getType() const = 0;
virtual void toString(StringPtr buf) const = 0;
virtual void toString(StringPtr buf,int indentLevel) const = 0;
friend class BaseStructure;
friend class BaseStructureArray;
friend class PVFieldPvt;
};
@@ -86,8 +89,8 @@ namespace epics { namespace pvData {
public:
virtual ~Structure();
virtual int const getNumberFields() const = 0;
virtual FieldConstPtr getField(StringConstPtr fieldName) const = 0;
virtual int getFieldIndex(StringConstPtr fieldName) const = 0;
virtual FieldConstPtr getField(StringConst fieldName) const = 0;
virtual int getFieldIndex(StringConst fieldName) const = 0;
virtual FieldConstPtrArray getFields() const = 0;
};
@@ -100,13 +103,13 @@ namespace epics { namespace pvData {
class FieldCreate {
public:
FieldConstPtr create(StringConstPtr fieldName,FieldConstPtr field) const;
ScalarConstPtr createScalar(StringConstPtr fieldName,ScalarType scalarType) const;
ScalarArrayConstPtr createScalarArray(StringConstPtr fieldName,
FieldConstPtr create(StringConst fieldName,FieldConstPtr field) const;
ScalarConstPtr createScalar(StringConst fieldName,ScalarType scalarType) const;
ScalarArrayConstPtr createScalarArray(StringConst fieldName,
ScalarType elementType) const;
StructureConstPtr createStructure (StringConstPtr fieldName,
StructureConstPtr createStructure (StringConst fieldName,
int numberFields,FieldConstPtrArray fields) const;
StructureArrayConstPtr createStructureArray(StringConstPtr fieldName,
StructureArrayConstPtr createStructureArray(StringConst fieldName,
StructureConstPtr structure) const;
protected:
FieldCreate();

4
pvDataApp/test/Makefile
View File

@@ -6,10 +6,6 @@ PROD_HOST += testIntrospect
testIntrospect_SRCS += testIntrospect.cpp
testIntrospect_LIBS += pvFactory
PROD_HOST += testDumpStdString
testDumpStdString_SRCS += testDumpStdString.cpp
testDumpStdString_LIBS += pvFactory
PROD_HOST += testPVAuxInfo
testPVAuxInfo_SRCS += testPVAuxInfo.cpp
testPVAuxInfo_LIBS += pvFactory

116
pvDataApp/test/testDumpStdString.cpp
View File

@@ -1,116 +0,0 @@
/* pvDataMain.cpp */
/* Author: Marty Kraimer Date: 17MAR2000 */
#include <stddef.h>
#include <stdlib.h>
#include <stddef.h>
#include <string.h>
#include <stdio.h>
#include "pvIntrospect.h"
using namespace epics::pvData;
using namespace std;
static void dumpString(char const prefix[],string const* value) {
printf("%s\n value %p",prefix,value);
// Just convert value to a pointer
int *pvalue = (int *)value;
// Now get what pvalue points to. It is the cstr.
char * cstr = (char *)*pvalue;
if(cstr==0) { printf("\n"); return; }
printf(" *value %p",cstr);
int * stuff = (int *)*pvalue;
//At least on my implementation the following is true
stuff -= 3;
printf(" length %d capacity %d refcount %d str %s\n",
stuff[0],stuff[1],stuff[2],cstr);
}
int main(int argc,char *argv[])
{
FieldCreate * pfieldCreate = getFieldCreate();
std::string valueName("value");
std::string* myString= new std::string("type ");
int numberFields = 2;
FieldConstPtr fields[numberFields];
std::string name0("high");
std::string name1("low");
dumpString("high",&name0);
dumpString("low",&name1);
printf("\ncreate field0 and field1\n");
fields[0] = pfieldCreate->createScalar(&name0,pvDouble);
fields[1] = pfieldCreate->createScalar(&name1,pvDouble);
printf("referenceCounts field0 %d field1 %d\n",
fields[0]->getReferenceCount(),
fields[1]->getReferenceCount());
dumpString("high",&name0);
dumpString("low",&name1);
printf("\ncreate scalarArray");
std::string scalarArrayName("scalarArray");
ScalarArrayConstPtr pscalarArray = pfieldCreate->createScalarArray(
&scalarArrayName,pvDouble);
myString->clear();
pscalarArray->toString(myString);
printf("%s\n",myString->c_str());
printf("referenceCount pscalarArray %d\n", pscalarArray->getReferenceCount());
dumpString("scalarArray",&scalarArrayName);
pscalarArray->incReferenceCount();
printf("after incReferenceCounnt referenceCount pscalarArray %d\n",
pscalarArray->getReferenceCount());
dumpString("high",&name0);
pscalarArray->decReferenceCount();
dumpString("after decReferenceCount scalarArray",&scalarArrayName);
printf("\ncreate structure\n");
StructureConstPtr pstructure = pfieldCreate->createStructure(
&valueName,numberFields,fields);
myString->clear();
pstructure->toString(myString);
printf("%s\n",myString->c_str());
FieldConstPtr pfield = pstructure;
myString->clear();
pfield->toString(myString);
printf("as Field\n%s\n",myString->c_str());
printf("referenceCounts pfield %d field0 %d field1 %d\n",
pfield->getReferenceCount(),
fields[0]->getReferenceCount(),
fields[1]->getReferenceCount());
dumpString("high",&name0);
dumpString("low",&name1);
pfield->incReferenceCount();
pfield->incReferenceCount();
printf("after incReferenceCounter twice referenceCounts pfield %d field0 %d field1 %d\n",
pfield->getReferenceCount(),
fields[0]->getReferenceCount(),
fields[1]->getReferenceCount());
dumpString("high",&name0);
dumpString("low",&name1);
pfield->decReferenceCount();
printf("after decReferenceCount referenceCounts pfield %d field0 %d field1 %d\n",
pfield->getReferenceCount(),
fields[0]->getReferenceCount(),
fields[1]->getReferenceCount());
dumpString("high",&name0);
dumpString("low",&name1);
StructureArrayConstPtr pstructureArray = pfieldCreate->createStructureArray(
&valueName,pstructure);
pstructureArray->incReferenceCount();
printf("after createStructureArray referenceCounts pstructureArray %d pfield %d field0 %d field1 %d\n",
pstructureArray->getReferenceCount(),
pfield->getReferenceCount(),
fields[0]->getReferenceCount(),
fields[1]->getReferenceCount());
pstructureArray->decReferenceCount();
printf("after structureArray decReferenceCount referenceCounts pfield %d field0 %d field1 %d\n",
pfield->getReferenceCount(),
fields[0]->getReferenceCount(),
fields[1]->getReferenceCount());
dumpString("high",&name0);
dumpString("low",&name1);
printf("field recReferenceCount\n");
pfield->decReferenceCount();
dumpString("high",&name0);
dumpString("low",&name1);
return(0);
}

68
pvDataApp/test/testIntrospect.cpp
View File

@@ -18,45 +18,45 @@ int main(int argc,char *argv[])
bool value = ScalarTypeFunc::isNumeric(scalarType);
printf("isNumeric %s\n",(value ? "true" : "false"));
std::string* myString= new std::string("type ");
TypeFunc::toString(myString,type);
*myString += " scalarType ";
ScalarTypeFunc::toString(myString,scalarType);
printf("%s\n",myString->c_str());
String myString("type ");
TypeFunc::toString(&myString,type);
myString += " scalarType ";
ScalarTypeFunc::toString(&myString,scalarType);
printf("%s\n",myString.c_str());
FieldCreate * pfieldCreate = getFieldCreate();
std::string valueName("value");
ScalarConstPtr pscalar = pfieldCreate->createScalar(&valueName,scalarType);
StringConst valueName("value");
ScalarConstPtr pscalar = pfieldCreate->createScalar(valueName,scalarType);
type = pscalar->getType();
myString->clear();
*myString += "type ";
TypeFunc::toString(myString,type);
printf("%s\n",myString->c_str());
myString->clear();
*myString += "fieldName ";
StringConstPtr pfieldName = pscalar->getFieldName();
*myString += *pfieldName;
printf("%s\n",myString->c_str());
myString->clear();
pscalar->toString(myString);
printf("%s\n",myString->c_str());
ScalarArrayConstPtr pscalarArray = pfieldCreate->createScalarArray(&valueName,pvString);
myString->clear();
pscalarArray->toString(myString);
printf("%s\n",myString->c_str());
myString.clear();
myString += "type ";
TypeFunc::toString(&myString,type);
printf("%s\n",myString.c_str());
myString.clear();
myString += "fieldName ";
StringConst fieldName = pscalar->getFieldName();
myString += fieldName;
printf("%s\n",myString.c_str());
myString.clear();
pscalar->toString(&myString);
printf("%s\n",myString.c_str());
ScalarArrayConstPtr pscalarArray = pfieldCreate->createScalarArray(valueName,pvString);
myString.clear();
pscalarArray->toString(&myString);
printf("%s\n",myString.c_str());
int numberFields = 2;
FieldConstPtr fields[numberFields];
std::string name0("high");
std::string name1("low");
fields[0] = pfieldCreate->createScalar(&name0,pvDouble);
fields[1] = pfieldCreate->createScalar(&name1,pvDouble);
StringConst name0("high");
StringConst name1("low");
fields[0] = pfieldCreate->createScalar(name0,pvDouble);
fields[1] = pfieldCreate->createScalar(name1,pvDouble);
StructureConstPtr pstructure = pfieldCreate->createStructure(
&valueName,numberFields,fields);
myString->clear();
pstructure->toString(myString);
printf("%s\n",myString->c_str());
valueName,numberFields,fields);
myString.clear();
pstructure->toString(&myString);
printf("%s\n",myString.c_str());
FieldConstPtr pfield = pstructure;
myString->clear();
pfield->toString(myString);
printf("as Field\n%s/n",myString->c_str());
myString.clear();
pfield->toString(&myString);
printf("as Field\n%s/n",myString.c_str());
return(0);
}

21
pvDataApp/test/testPVAuxInfo.cpp
View File

@@ -13,13 +13,12 @@ using namespace epics::pvData;
static FieldCreate * fieldCreate = 0;
static PVDataCreate *pvDataCreate = 0;
static std::string theBuffer("");
static std::string *buffer = &theBuffer;
static String buffer("");
void testDouble() {
printf("\ntestDouble\n");
std::string valueName("value");
ScalarConstPtr pscalar = fieldCreate->createScalar(&valueName,pvDouble);
StringConst valueName("value");
ScalarConstPtr pscalar = fieldCreate->createScalar(valueName,pvDouble);
PVScalar *pvScalar = pvDataCreate->createPVScalar(0,pscalar);
PVDouble *pvValue = dynamic_cast<PVDouble *>(pvScalar);
double value = 2;
@@ -29,15 +28,15 @@ void testDouble() {
fprintf(stderr,"ERROR getValue put %f get %f\n",value,getValue);
}
PVAuxInfo *auxInfo = pvValue->getPVAuxInfo();
std::string stringName("string");
pvScalar = auxInfo->createInfo(&stringName,pvDouble);
StringConst stringName("string");
pvScalar = auxInfo->createInfo(stringName,pvDouble);
PVDouble *doubleInfo = dynamic_cast<PVDouble *>(pvScalar);
doubleInfo->put(100.0);
pvScalar = auxInfo->getInfo(&stringName);
buffer->clear();
*buffer += "stringInfo ";
pvScalar->toString(buffer);
printf("%s\n",buffer->c_str());
pvScalar = auxInfo->getInfo(stringName);
buffer.clear();
buffer += "stringInfo ";
pvScalar->toString(&buffer);
printf("%s\n",buffer.c_str());
delete pvValue;
}

21
pvDataApp/test/testPVScalar.cpp
View File

@@ -13,13 +13,12 @@ using namespace epics::pvData;
static FieldCreate * pfieldCreate = 0;
static PVDataCreate *pvDataCreate = 0;
static std::string theBuffer("");
static std::string *buffer = &theBuffer;
static String buffer("");
void testDouble() {
printf("\ntestDouble\n");
std::string valueName("value");
ScalarConstPtr pscalar = pfieldCreate->createScalar(&valueName,pvDouble);
StringConst valueName("value");
ScalarConstPtr pscalar = pfieldCreate->createScalar(valueName,pvDouble);
PVScalar *pvScalar = pvDataCreate->createPVScalar(0,pscalar);
PVDouble *pvValue = (PVDouble *)pvScalar;
double value = 2;
@@ -30,9 +29,9 @@ void testDouble() {
fprintf(stderr,"ERROR getValue put %f get %f\n",value,getValue);
}
FieldConstPtr field = pvValue->getField();
buffer->clear();
field->toString(buffer);
printf("%s\n",buffer->c_str());
buffer.clear();
field->toString(&buffer);
printf("%s\n",buffer.c_str());
epicsBoolean isImmutable = pvValue->isImmutable();
PVStructure *pvParent = pvValue->getParent();
printf("immutable %s parent %p\n",
@@ -47,10 +46,10 @@ void testDouble() {
if(scalar!=field) {
fprintf(stderr,"ERROR field!=scalar field %p scalar %p\n",field,scalar);
}
buffer->clear();
*buffer += "value ";
pvValue->toString(buffer);
printf("%s\n",buffer->c_str());
buffer.clear();
buffer += "value ";
pvValue->toString(&buffer);
printf("%s\n",buffer.c_str());
delete pvValue;
}