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

use const where appropriate

Browse Source
This commit is contained in:
Marty Kraimer
2012-05-22 11:51:53 -04:00
parent 770e63b8da
commit 126fe9c711
11 changed files with 254 additions and 194 deletions
Download Patch File Download Diff File Expand all files Collapse all files

98
pvDataApp/factory/Convert.cpp
View File

@@ -376,13 +376,13 @@ static size_t convertToStringArray(PVScalarArray *pv, size_t offset,
size_t len,StringArray & to, size_t toOffset);
static void convertToString(StringBuilder buffer,
PVField *pv,int indentLevel);
PVField const *pv,int indentLevel);
static void convertStructure(StringBuilder buffer,
PVStructure *data,int indentLevel);
PVStructure const *data,int indentLevel);
static void convertArray(StringBuilder buffer,
PVScalarArray * pv,int indentLevel);
PVScalarArray const* pv,int indentLevel);
static void convertStructureArray(StringBuilder buffer,
PVStructureArray * pvdata,int indentLevel);
PVStructureArray const * pvdata,int indentLevel);
static size_t copyArrayDataReference(PVScalarArray *from,PVArray *to);
static size_t copyNumericArray(PVScalarArray *from,
size_t offset, PVScalarArray *to, size_t toOffset, size_t len);
@@ -448,12 +448,12 @@ void Convert::getString(StringBuilder buf,PVFieldPtr const & pvField)
convertToString(buf,pvField.get(),0);
}
void Convert::getString(StringBuilder buf,PVField *pvField,int indentLevel)
void Convert::getString(StringBuilder buf,PVField const *pvField,int indentLevel)
{
convertToString(buf,pvField,indentLevel);
}
void Convert::getString(StringBuilder buf,PVField *pvField)
void Convert::getString(StringBuilder buf,PVField const *pvField)
{
convertToString(buf,pvField,0);
}
@@ -1233,121 +1233,121 @@ size_t Convert::toDoubleArray(PVScalarArrayPtr const &pv, size_t offset, size_t
return convertToDoubleArray(pv.get(), offset, length, to, toOffset);
}
size_t Convert::fromByteArray(PVScalarArrayPtr const &pv, size_t offset, size_t length,
size_t Convert::fromByteArray(PVScalarArrayPtr &pv, size_t offset, size_t length,
const int8 from[], size_t fromOffset)
{
return convertFromByteArray(pv.get(), offset, length, from, fromOffset);
}
size_t Convert::fromByteArray(PVScalarArrayPtr const &pv, size_t offset, size_t length,
size_t Convert::fromByteArray(PVScalarArrayPtr &pv, size_t offset, size_t length,
const ByteArray & from, size_t fromOffset)
{
return convertFromByteArray(pv.get(), offset, length, get(from), fromOffset);
}
size_t Convert::fromShortArray(PVScalarArrayPtr const &pv, size_t offset, size_t length,
size_t Convert::fromShortArray(PVScalarArrayPtr &pv, size_t offset, size_t length,
const int16 from[], size_t fromOffset)
{
return convertFromShortArray(pv.get(), offset, length, from, fromOffset);
}
size_t Convert::fromShortArray(PVScalarArrayPtr const &pv, size_t offset, size_t length,
size_t Convert::fromShortArray(PVScalarArrayPtr &pv, size_t offset, size_t length,
const ShortArray & from, size_t fromOffset)
{
return convertFromShortArray(pv.get(), offset, length, get(from), fromOffset);
}
size_t Convert::fromIntArray(PVScalarArrayPtr const &pv, size_t offset, size_t length,
size_t Convert::fromIntArray(PVScalarArrayPtr &pv, size_t offset, size_t length,
const int32 from[], size_t fromOffset)
{
return convertFromIntArray(pv.get(), offset, length, from, fromOffset);
}
size_t Convert::fromIntArray(PVScalarArrayPtr const &pv, size_t offset, size_t length,
size_t Convert::fromIntArray(PVScalarArrayPtr &pv, size_t offset, size_t length,
const IntArray & from, size_t fromOffset)
{
return convertFromIntArray(pv.get(), offset, length, get(from), fromOffset);
}
size_t Convert::fromLongArray(PVScalarArrayPtr const &pv, size_t offset, size_t length,
size_t Convert::fromLongArray(PVScalarArrayPtr &pv, size_t offset, size_t length,
const int64 from[], size_t fromOffset)
{
return convertFromLongArray(pv.get(), offset, length, from, fromOffset);
}
size_t Convert::fromLongArray(PVScalarArrayPtr const &pv, size_t offset, size_t length,
size_t Convert::fromLongArray(PVScalarArrayPtr &pv, size_t offset, size_t length,
const LongArray & from, size_t fromOffset)
{
return convertFromLongArray(pv.get(), offset, length, get(from), fromOffset);
}
size_t Convert::fromUByteArray(PVScalarArrayPtr const &pv, size_t offset, size_t length,
size_t Convert::fromUByteArray(PVScalarArrayPtr &pv, size_t offset, size_t length,
const uint8 from[], size_t fromOffset)
{
return convertFromUByteArray(pv.get(), offset, length, from, fromOffset);
}
size_t Convert::fromUByteArray(PVScalarArrayPtr const &pv, size_t offset, size_t length,
size_t Convert::fromUByteArray(PVScalarArrayPtr &pv, size_t offset, size_t length,
const UByteArray & from, size_t fromOffset)
{
return convertFromUByteArray(pv.get(), offset, length, get(from), fromOffset);
}
size_t Convert::fromUShortArray(PVScalarArrayPtr const &pv, size_t offset, size_t length,
size_t Convert::fromUShortArray(PVScalarArrayPtr &pv, size_t offset, size_t length,
const uint16 from[], size_t fromOffset)
{
return convertFromUShortArray(pv.get(), offset, length, from, fromOffset);
}
size_t Convert::fromUShortArray(PVScalarArrayPtr const &pv, size_t offset, size_t length,
size_t Convert::fromUShortArray(PVScalarArrayPtr &pv, size_t offset, size_t length,
const UShortArray &from, size_t fromOffset)
{
return convertFromUShortArray(pv.get(), offset, length, get(from), fromOffset);
}
size_t Convert::fromUIntArray(PVScalarArrayPtr const &pv, size_t offset, size_t length,
size_t Convert::fromUIntArray(PVScalarArrayPtr &pv, size_t offset, size_t length,
const uint32 from[], size_t fromOffset)
{
return convertFromUIntArray(pv.get(), offset, length, from, fromOffset);
}
size_t Convert::fromUIntArray(PVScalarArrayPtr const &pv, size_t offset, size_t length,
size_t Convert::fromUIntArray(PVScalarArrayPtr &pv, size_t offset, size_t length,
const UIntArray & from, size_t fromOffset)
{
return convertFromUIntArray(pv.get(), offset, length, get(from), fromOffset);
}
size_t Convert::fromULongArray(PVScalarArrayPtr const &pv, size_t offset, size_t length,
size_t Convert::fromULongArray(PVScalarArrayPtr &pv, size_t offset, size_t length,
const uint64 from[], size_t fromOffset)
{
return convertFromULongArray(pv.get(), offset, length, from, fromOffset);
}
size_t Convert::fromULongArray(PVScalarArrayPtr const &pv, size_t offset, size_t length,
size_t Convert::fromULongArray(PVScalarArrayPtr &pv, size_t offset, size_t length,
const ULongArray &from, size_t fromOffset)
{
return convertFromULongArray(pv.get(), offset, length, get(from), fromOffset);
}
size_t Convert::fromFloatArray(PVScalarArrayPtr const &pv, size_t offset, size_t length,
size_t Convert::fromFloatArray(PVScalarArrayPtr &pv, size_t offset, size_t length,
const float from[], size_t fromOffset)
{
return convertFromFloatArray(pv.get(), offset, length, from, fromOffset);
}
size_t Convert::fromFloatArray(PVScalarArrayPtr const &pv, size_t offset, size_t length,
size_t Convert::fromFloatArray(PVScalarArrayPtr &pv, size_t offset, size_t length,
const FloatArray & from, size_t fromOffset)
{
return convertFromFloatArray(pv.get(), offset, length, get(from), fromOffset);
}
size_t Convert::fromDoubleArray(PVScalarArrayPtr const &pv, size_t offset, size_t length,
size_t Convert::fromDoubleArray(PVScalarArrayPtr &pv, size_t offset, size_t length,
const double from[], size_t fromOffset)
{
return convertFromDoubleArray(pv.get(), offset, length, from, fromOffset);
}
size_t Convert::fromDoubleArray(PVScalarArrayPtr const &pv, size_t offset, size_t length,
size_t Convert::fromDoubleArray(PVScalarArrayPtr &pv, size_t offset, size_t length,
const DoubleArray & from, size_t fromOffset)
{
return convertFromDoubleArray(pv.get(), offset, length, get(from), fromOffset);
@@ -2604,24 +2604,24 @@ size_t convertToStringArray(PVScalarArray *pv,
}
void convertToString(StringBuilder buffer,PVField * pv,int indentLevel)
void convertToString(StringBuilder buffer,PVField const * pv,int indentLevel)
{
Type type = pv->getField()->getType();
if(type==scalarArray) {
convertArray(buffer,static_cast<PVScalarArray *>(pv),indentLevel);
convertArray(buffer,static_cast<PVScalarArray const *>(pv),indentLevel);
return;
}
if(type==structure) {
convertStructure(buffer,static_cast<PVStructure*>(pv),indentLevel);
convertStructure(buffer,static_cast<PVStructure const *>(pv),indentLevel);
return;
}
if(type==structureArray) {
convertStructureArray(
buffer,static_cast<PVStructureArray*>(pv),indentLevel);
buffer,static_cast<PVStructureArray const *>(pv),indentLevel);
return;
}
PVScalar *pvScalar = static_cast<PVScalar*>(pv);
ScalarConstPtr pscalar = pvScalar->getScalar();
PVScalar const *pvScalar = static_cast<PVScalar const *>(pv);
const ScalarConstPtr & pscalar = pvScalar->getScalar();
ScalarType scalarType = pscalar->getScalarType();
ScalarTypeFunc::toString(buffer,scalarType);
*buffer += " ";
@@ -2629,7 +2629,7 @@ void convertToString(StringBuilder buffer,PVField * pv,int indentLevel)
*buffer += " ";
switch(scalarType) {
case pvBoolean: {
PVBoolean *data = static_cast<PVBoolean*>(pv);
PVBoolean const *data = static_cast<PVBoolean const *>(pv);
bool value = data->get();
if(value) {
*buffer += "true";
@@ -2639,77 +2639,77 @@ void convertToString(StringBuilder buffer,PVField * pv,int indentLevel)
}
return;
case pvByte: {
PVByte *data = static_cast<PVByte*>(pv);
PVByte const *data = static_cast<PVByte const *>(pv);
char xxx[30];
sprintf(xxx,"%d",(int)data->get());
*buffer += xxx;
}
return;
case pvShort: {
PVShort *data = static_cast<PVShort*>(pv);
PVShort const *data = static_cast<PVShort const *>(pv);
char xxx[30];
sprintf(xxx,"%d",(int)data->get());
*buffer += xxx;
}
return;
case pvInt: {
PVInt *data = static_cast<PVInt*>(pv);
PVInt const *data = static_cast<PVInt const *>(pv);
char xxx[30];
sprintf(xxx,"%d",(int)data->get());
*buffer += xxx;
}
return;
case pvLong: {
PVLong *data = static_cast<PVLong*>(pv);
PVLong const *data = static_cast<PVLong const *>(pv);
char xxx[30];
sprintf(xxx,"%lld",(long long)data->get());
*buffer += xxx;
}
return;
case pvUByte: {
PVUByte *data = static_cast<PVUByte*>(pv);
PVUByte const *data = static_cast<PVUByte const *>(pv);
char xxx[30];
sprintf(xxx,"%u",(unsigned int)data->get());
*buffer += xxx;
}
return;
case pvUShort: {
PVUShort *data = static_cast<PVUShort*>(pv);
PVUShort const *data = static_cast<PVUShort const *>(pv);
char xxx[30];
sprintf(xxx,"%u",(unsigned int)data->get());
*buffer += xxx;
}
return;
case pvUInt: {
PVUInt *data = static_cast<PVUInt*>(pv);
PVUInt const *data = static_cast<PVUInt const *>(pv);
char xxx[30];
sprintf(xxx,"%u",(unsigned int)data->get());
*buffer += xxx;
}
return;
case pvULong: {
PVULong *data = static_cast<PVULong*>(pv);
PVULong const *data = static_cast<PVULong const *>(pv);
char xxx[30];
sprintf(xxx,"%llu",(unsigned long long)data->get());
*buffer += xxx;
}
return;
case pvFloat: {
PVFloat *data = static_cast<PVFloat*>(pv);
PVFloat const *data = static_cast<PVFloat const *>(pv);
char xxx[30];
sprintf(xxx,"%g",data->get());
*buffer += xxx;
}
return;
case pvDouble: {
PVDouble *data = static_cast<PVDouble*>(pv);
PVDouble const *data = static_cast<PVDouble const *>(pv);
char xxx[30];
sprintf(xxx,"%lg",data->get());
*buffer += xxx;
}
return;
case pvString: {
PVString *data = static_cast<PVString*>(pv);
PVString const *data = static_cast<PVString const *>(pv);
*buffer += data->get();
}
return;
@@ -2718,7 +2718,7 @@ void convertToString(StringBuilder buffer,PVField * pv,int indentLevel)
}
}
void convertStructure(StringBuilder buffer,PVStructure *data,int indentLevel)
void convertStructure(StringBuilder buffer,PVStructure const *data,int indentLevel)
{
String extendsName = data->getExtendsStructureName();
if(extendsName.length()<=0) {
@@ -2739,8 +2739,9 @@ void convertStructure(StringBuilder buffer,PVStructure *data,int indentLevel)
}
}
void convertArray(StringBuilder buffer,PVScalarArray * pv,int indentLevel)
void convertArray(StringBuilder buffer,PVScalarArray const * xxx,int indentLevel)
{
PVScalarArray *pv = const_cast<PVScalarArray *>(xxx);
ScalarArrayConstPtr array = pv->getScalarArray();
ScalarType type = array->getElementType();
ScalarTypeFunc::toString(buffer,type);
@@ -2749,7 +2750,7 @@ void convertArray(StringBuilder buffer,PVScalarArray * pv,int indentLevel)
*buffer += " ";
switch(type) {
case pvBoolean: {
PVBooleanArray *pvdata = static_cast<PVBooleanArray*>(pv);
PVBooleanArray *pvdata = static_cast<PVBooleanArray *>(pv);
BooleanArrayData data;
*buffer += "[";
for(size_t i=0; i < pvdata->getLength(); i++) {
@@ -2989,8 +2990,9 @@ void convertArray(StringBuilder buffer,PVScalarArray * pv,int indentLevel)
}
void convertStructureArray(StringBuilder buffer,
PVStructureArray * pvdata,int indentLevel)
PVStructureArray const * xxx,int indentLevel)
{
PVStructureArray *pvdata = const_cast<PVStructureArray *>(xxx);
*buffer += "structure[] ";
*buffer += pvdata->getFieldName();
*buffer += " ";

2
pvDataApp/factory/PVArray.cpp
View File

@@ -57,7 +57,7 @@ namespace epics { namespace pvData {
}
bool PVArray::isCapacityMutable()
bool PVArray::isCapacityMutable() const
{
if(PVField::isImmutable()) {
return false;

15
pvDataApp/factory/PVDataCreateFactory.cpp
View File

@@ -37,7 +37,7 @@ public:
BasePVScalar(ScalarConstPtr const & scalar);
virtual ~BasePVScalar();
virtual T get();
virtual T get() const ;
virtual void put(T val);
virtual void serialize(ByteBuffer *pbuffer,
SerializableControl *pflusher) const;
@@ -57,7 +57,7 @@ template<typename T>
BasePVScalar<T>::~BasePVScalar() {}
template<typename T>
T BasePVScalar<T>::get() { return value;}
T BasePVScalar<T>::get() const { return value;}
template<typename T>
void BasePVScalar<T>::put(T val){value = val;}
@@ -98,7 +98,7 @@ public:
BasePVString(ScalarConstPtr const & scalar);
virtual ~BasePVString();
virtual String get();
virtual String get() const ;
virtual void put(String val);
virtual void serialize(ByteBuffer *pbuffer,
SerializableControl *pflusher) const;
@@ -116,7 +116,7 @@ BasePVString::BasePVString(ScalarConstPtr const & scalar)
BasePVString::~BasePVString() {}
String BasePVString::get() { return value;}
String BasePVString::get() const { return value;}
void BasePVString::put(String val){value = val;}
@@ -620,7 +620,12 @@ PVStructurePtr PVDataCreate::createPVStructure(
FieldConstPtrArray fields(num);
for (size_t i=0;i<num;i++) fields[i] = pvFields[i]->getField();
StructureConstPtr structure = fieldCreate->createStructure(fieldNames,fields);
return PVStructurePtr(new PVStructure(structure,pvFields));
PVStructurePtr pvStructure(new PVStructure(structure,pvFields));
const PVFieldPtrArray & xxx = pvStructure->getPVFields();
for(size_t i=0; i<pvFields.size();i++) {
convert->copy(pvFields[i],xxx[i]);
}
return pvStructure;
}
PVStructurePtr PVDataCreate::createPVStructure(PVStructurePtr const & structToClone)

43
pvDataApp/factory/PVField.cpp
View File

@@ -58,7 +58,7 @@ void PVField::message(String message,MessageType messageType)
PVField::message(fieldName,message,messageType);
}
String PVField::getFieldName()
String PVField::getFieldName() const
{
return fieldName;
}
@@ -77,19 +77,19 @@ void PVField::setRequester(Requester *requester)
requester = requester;
}
size_t PVField::getFieldOffset()
size_t PVField::getFieldOffset() const
{
if(nextFieldOffset==0) computeOffset(this);
return fieldOffset;
}
size_t PVField::getNextFieldOffset()
size_t PVField::getNextFieldOffset() const
{
if(nextFieldOffset==0) computeOffset(this);
return nextFieldOffset;
}
size_t PVField::getNumberFields()
size_t PVField::getNumberFields() const
{
if(nextFieldOffset==0) computeOffset(this);
return (nextFieldOffset - fieldOffset);
@@ -102,15 +102,15 @@ PVAuxInfoPtr & PVField::getPVAuxInfo(){
return pvAuxInfo;
}
bool PVField::isImmutable() {return immutable;}
bool PVField::isImmutable() const {return immutable;}
void PVField::setImmutable() {immutable = true;}
FieldConstPtr & PVField::getField() {return field;}
const FieldConstPtr & PVField::getField() const {return field;}
PVStructure *PVField::getParent() {return parent;}
PVStructure *PVField::getParent() const {return parent;}
void PVField::replacePVField(PVFieldPtr & newPVField)
void PVField::replacePVField(const PVFieldPtr & newPVField)
{
if(parent==NULL) {
throw std::logic_error("no parent");
@@ -189,15 +189,16 @@ void PVField::toString(StringBuilder buf,int indentLevel)
if(pvAuxInfo.get()!=NULL) pvAuxInfo->toString(buf,indentLevel);
}
void PVField::computeOffset(PVField * pvField) {
PVStructure * pvTop = pvField->getParent();
void PVField::computeOffset(const PVField * pvField) {
const PVStructure * pvTop = pvField->getParent();
if(pvTop==NULL) {
if(pvField->getField()->getType()!=structure) {
pvField->fieldOffset = 0;
pvField->nextFieldOffset = 1;
PVField *xxx = const_cast<PVField *>(pvField);
xxx->fieldOffset = 0;
xxx->nextFieldOffset = 1;
return;
}
pvTop = static_cast<PVStructure *>(pvField);
pvTop = static_cast<const PVStructure *>(pvField);
} else {
while(pvTop->getParent()!=NULL) pvTop = pvTop->getParent();
}
@@ -224,15 +225,16 @@ void PVField::computeOffset(PVField * pvField) {
}
}
PVField *top = (PVField *)pvTop;
top->fieldOffset = 0;
top->nextFieldOffset = nextOffset;
PVField *xxx = const_cast<PVField *>(top);
xxx->fieldOffset = 0;
xxx->nextFieldOffset = nextOffset;
}
void PVField::computeOffset(PVField * pvField,size_t offset) {
void PVField::computeOffset(const PVField * pvField,size_t offset) {
int beginOffset = offset;
int nextOffset = offset + 1;
PVStructure *pvStructure = static_cast<PVStructure *>(pvField);
PVFieldPtrArray pvFields = pvStructure->getPVFields();
const PVStructure *pvStructure = static_cast<const PVStructure *>(pvField);
const PVFieldPtrArray pvFields = pvStructure->getPVFields();
for(size_t i=0; i < pvStructure->getStructure()->getNumberFields(); i++) {
offset = nextOffset;
PVField *pvSubField = pvFields[i].get();
@@ -252,8 +254,9 @@ void PVField::computeOffset(PVField * pvField,size_t offset) {
}
}
}
pvField->fieldOffset = beginOffset;
pvField->nextFieldOffset = nextOffset;
PVField *xxx = const_cast<PVField *>(pvField);
xxx->fieldOffset = beginOffset;
xxx->nextFieldOffset = nextOffset;
}
}}

2
pvDataApp/factory/PVScalar.cpp
View File

@@ -20,7 +20,7 @@ namespace epics { namespace pvData {
PVScalar::PVScalar(ScalarConstPtr const & scalar)
: PVField(scalar) {}
ScalarConstPtr PVScalar::getScalar()
const ScalarConstPtr PVScalar::getScalar() const
{
return static_pointer_cast<const Scalar>(PVField::getField());
}

2
pvDataApp/factory/PVScalarArray.cpp
View File

@@ -20,7 +20,7 @@ namespace epics { namespace pvData {
PVScalarArray::PVScalarArray(ScalarArrayConstPtr const & scalarArray)
: PVArray(scalarArray) {}
ScalarArrayConstPtr PVScalarArray::getScalarArray()
const ScalarArrayConstPtr PVScalarArray::getScalarArray() const
{
return static_pointer_cast<const ScalarArray>(PVField::getField());
}

54
pvDataApp/factory/PVStructure.cpp
View File

@@ -37,7 +37,7 @@ static PVStructurePtr nullPVStructure;
static PVStructureArrayPtr nullPVStructureArray;
static PVScalarArrayPtr nullPVScalarArray;
static PVFieldPtr findSubField(String fieldName,PVStructure *pvStructure);
static PVFieldPtr findSubField(String fieldName,const PVStructure *pvStructure);
PVStructure::PVStructure(StructureConstPtr const & structurePtr)
: PVField(structurePtr),
@@ -47,13 +47,14 @@ PVStructure::PVStructure(StructureConstPtr const & structurePtr)
size_t numberFields = structurePtr->getNumberFields();
FieldConstPtrArray fields = structurePtr->getFields();
StringArray fieldNames = structurePtr->getFieldNames();
pvFields.reserve(numberFields);
PVFieldPtrArray * xxx = const_cast<PVFieldPtrArray *>(&pvFields);
xxx->reserve(numberFields);
PVDataCreatePtr pvDataCreate = getPVDataCreate();
for(size_t i=0; i<numberFields; i++) {
pvFields.push_back(pvDataCreate->createPVField(fields[i]));
xxx->push_back(pvDataCreate->createPVField(fields[i]));
}
for(size_t i=0; i<numberFields; i++) {
pvFields[i]->setParentAndName(this,fieldNames[i]);
(*xxx)[i]->setParentAndName(this,fieldNames[i]);
}
}
@@ -66,9 +67,14 @@ PVStructure::PVStructure(StructureConstPtr const & structurePtr,
{
size_t numberFields = structurePtr->getNumberFields();
StringArray fieldNames = structurePtr->getFieldNames();
pvFields = pvs;
PVFieldPtrArray * xxx = const_cast<PVFieldPtrArray *>(&pvFields);
xxx->reserve(numberFields);
PVDataCreatePtr pvDataCreate = getPVDataCreate();
for(size_t i=0; i<numberFields; i++) {
pvFields[i]->setParentAndName(this,fieldNames[i]);
xxx->push_back(pvDataCreate->createPVField(pvs[i]->getField()));
}
for(size_t i=0; i<numberFields; i++) {
(*xxx)[i]->setParentAndName(this,fieldNames[i]);
}
}
@@ -76,23 +82,23 @@ PVStructure::~PVStructure()
{
}
StructureConstPtr &PVStructure::getStructure()
StructureConstPtr PVStructure::getStructure() const
{
return structurePtr;
}
PVFieldPtrArray & PVStructure::getPVFields()
const PVFieldPtrArray & PVStructure::getPVFields() const
{
return pvFields;
}
PVFieldPtr PVStructure::getSubField(String fieldName)
PVFieldPtr PVStructure::getSubField(String fieldName) const
{
return findSubField(fieldName,this);
}
PVFieldPtr PVStructure::getSubField(size_t fieldOffset)
PVFieldPtr PVStructure::getSubField(size_t fieldOffset) const
{
if(fieldOffset<=getFieldOffset()) {
return nullPVField;
@@ -115,13 +121,8 @@ void PVStructure::appendPVField(String fieldName, PVFieldPtr const & pvField)
{
size_t origLength = pvFields.size();
size_t newLength = origLength+1;
PVFieldPtrArray newPVFields;
newPVFields.reserve(newLength);
for(size_t i=0; i<origLength; i++) {
newPVFields.push_back(pvFields[i]);
}
newPVFields.push_back(pvField);
pvFields.swap(newPVFields);
PVFieldPtrArray * xxx = const_cast<PVFieldPtrArray *>(&pvFields);
xxx->push_back(pvField);
FieldConstPtr field = getFieldCreate()->appendField(structurePtr,fieldName,pvField->getField());
replaceField(field);
structurePtr = static_pointer_cast<const Structure>(field);
@@ -137,15 +138,11 @@ void PVStructure::appendPVFields(StringArray const & fieldNames, PVFieldPtrArray
size_t extra = fieldNames.size();
if(extra==0) return;
size_t newLength = origLength + extra;
PVFieldPtrArray newPVFields;
newPVFields.reserve(newLength);
for(size_t i=0; i<origLength; i++) {
newPVFields.push_back(this->pvFields[i]);
}
PVFieldPtrArray * xxx = const_cast<PVFieldPtrArray *>(&this->pvFields);
xxx->reserve(newLength);
for(size_t i=0; i<extra; i++) {
newPVFields.push_back(pvFields[i]);
xxx->push_back(pvFields[i]);
}
this->pvFields.swap(newPVFields);
FieldConstPtrArray fields;
fields.reserve(extra);
for(size_t i=0; i<extra; i++) fields.push_back(pvFields[i]->getField());
@@ -154,7 +151,7 @@ void PVStructure::appendPVFields(StringArray const & fieldNames, PVFieldPtrArray
structurePtr = static_pointer_cast<const Structure>(field);
StringArray names = structurePtr->getFieldNames();
for(size_t i=0; i<newLength; i++) {
pvFields[i]->setParentAndName(this,names[i]);
(*xxx)[i]->setParentAndName(this,names[i]);
}
}
@@ -184,7 +181,8 @@ void PVStructure::removePVField(String fieldName)
fields.push_back(origFields[i]);
}
}
pvFields.swap(newPVFields);
PVFieldPtrArray * xxx = const_cast<PVFieldPtrArray *>(&pvFields);
xxx->swap(newPVFields);
FieldConstPtr field = getFieldCreate()->createStructure(newFieldNames,fields);
replaceField(field);
structurePtr = static_pointer_cast<const Structure>(field);
@@ -525,7 +523,7 @@ PVStructureArrayPtr PVStructure::getStructureArrayField(
return nullPVStructureArray;
}
String PVStructure::getExtendsStructureName()
String PVStructure::getExtendsStructureName() const
{
return extendsStructureName;
}
@@ -621,7 +619,7 @@ void PVStructure::deserialize(ByteBuffer *pbuffer,
}
}
static PVFieldPtr findSubField(String fieldName,PVStructure *pvStructure) {
static PVFieldPtr findSubField(String fieldName,PVStructure const *pvStructure) {
if( fieldName.length()<1) return nullPVField;
String::size_type index = fieldName.find('.');
String name = fieldName;

2
pvDataApp/factory/PVStructureArray.cpp
View File

@@ -98,7 +98,7 @@ void PVStructureArray::setCapacity(size_t capacity) {
}
StructureArrayConstPtr PVStructureArray::getStructureArray()
StructureArrayConstPtr PVStructureArray::getStructureArray() const
{
return structureArray;
}

151
pvDataApp/pv/convert.h
View File

@@ -112,14 +112,14 @@ public:
* If a PVField is a structure or array be prepared for a very long string.
* @param indentLevel indentation level
*/
void getString(StringBuilder buf,PVField * pvField,int indentLevel);
void getString(StringBuilder buf,PVField const * pvField,int indentLevel);
/**
* Convert a PVField to a string.
* param buf buffer for the result
* @param pv The PVField to convert to a string.
* If the PVField is a structure or array be prepared for a very long string.
*/
void getString(StringBuilder buf,PVField * pvField);
void getString(StringBuilder buf,PVField const * pvField);
/**
* Convert from an array of String to a PVScalar
* @param pv The PV.
@@ -127,7 +127,10 @@ public:
* @param fromStartIndex The first element if the array of strings.
* @throws std::logic_error if the array of String does not have a valid values.
*/
std::size_t fromString(PVStructurePtr const &pv, StringArray const & from, std::size_t fromStartIndex = 0);
std::size_t fromString(
PVStructurePtr const &pv,
StringArray const & from,
std::size_t fromStartIndex = 0);
/**
* Convert from a String to a PVScalar
* @param pv The PV.
@@ -157,8 +160,11 @@ public:
* @throws std::invalid_argument if the element Type is not a scalar.
* @throws std::logic_error if the String does not have a valid value.
*/
std::size_t fromStringArray(PVScalarArrayPtr const & pv, std::size_t offset, std::size_t length,
StringArray const & from, std::size_t fromOffset);
std::size_t fromStringArray(
PVScalarArrayPtr const & pv,
std::size_t offset, std::size_t length,
StringArray const & from,
std::size_t fromOffset);
/**
* Convert a PVScalarArray to a String array.
* @param pv The PV.
@@ -168,8 +174,11 @@ public:
* @param toOffset Starting element in the string array.
* @return Number of elements converted.
*/
std::size_t toStringArray(PVScalarArrayPtr const & pv, std::size_t offset, std::size_t length,
StringArray & to, std::size_t toOffset);
std::size_t toStringArray(PVScalarArrayPtr const & pv,
std::size_t offset,
std::size_t length,
StringArray & to,
std::size_t toOffset);
/**
* Are from and to valid arguments to copy.
* This first checks of both arguments have the same Type.
@@ -203,7 +212,8 @@ public:
* @return (false,true) If the arguments (are not, are) compatible.
*/
bool isCopyScalarCompatible(
ScalarConstPtr const & from, ScalarConstPtr const & to);
ScalarConstPtr const & from,
ScalarConstPtr const & to);
/**
* Copy from a scalar pv to another scalar pv.
* @param from the source.
@@ -218,7 +228,8 @@ public:
* @param to The to array.
* @return (false,true) If the arguments (are not, are) compatible.
*/
bool isCopyScalarArrayCompatible(ScalarArrayConstPtr const & from,
bool isCopyScalarArrayCompatible(
ScalarArrayConstPtr const & from,
ScalarArrayConstPtr const & to);
/**
* Convert from a source PV array to a destination PV array.
@@ -230,8 +241,12 @@ public:
* @return Number of elements converted.
* @throws std::invalid_argument if the arguments are not compatible.
*/
std::size_t copyScalarArray(PVScalarArrayPtr const & from, std::size_t offset,
PVScalarArrayPtr const & to, std::size_t toOffset, std::size_t length);
std::size_t copyScalarArray(
PVScalarArrayPtr const & from,
std::size_t offset,
PVScalarArrayPtr const & to,
std::size_t toOffset,
std::size_t length);
/**
* Are from and to valid arguments for copyStructure.
* They are only compatible if they have the same Structure description.
@@ -424,8 +439,11 @@ public:
* @return number of elements converted
* @throws std::invalid_argument if the element type is not numeric
*/
std::size_t toByteArray(PVScalarArrayPtr const & pv, std::size_t offset, std::size_t length,
int8* to, std::size_t toOffset);
std::size_t toByteArray(PVScalarArrayPtr const & pv,
std::size_t offset,
std::size_t length,
int8* to,
std::size_t toOffset);
/**
* Convert a PV array to a short array.
* @param pv a PV
@@ -436,8 +454,11 @@ public:
* @return number of elements converted
* @throws std::invalid_argument if the element type is not numeric
*/
std::size_t toShortArray(PVScalarArrayPtr const & pv, std::size_t offset, std::size_t length,
int16* to, std::size_t toOffset);
std::size_t toShortArray(PVScalarArrayPtr const & pv,
std::size_t offset,
std::size_t length,
int16* to,
std::size_t toOffset);
/**
* Convert a PV array to an int array.
* @param pv a PV
@@ -448,8 +469,11 @@ public:
* @return number of elements converted
* @throws std::invalid_argument if the element type is not numeric
*/
std::size_t toIntArray(PVScalarArrayPtr const & pv, std::size_t offset, std::size_t length,
int32* to, std::size_t toOffset);
std::size_t toIntArray(PVScalarArrayPtr const & pv,
std::size_t offset,
std::size_t length,
int32* to,
std::size_t toOffset);
/**
* Convert a PV array to a long array.
* @param pv a PV
@@ -460,8 +484,11 @@ public:
* @return number of elements converted
* @throws std::invalid_argument if the element type is not numeric
*/
std::size_t toLongArray(PVScalarArrayPtr const & pv, std::size_t offset, std::size_t length,
int64* to, std::size_t toOffset);
std::size_t toLongArray(PVScalarArrayPtr const & pv,
std::size_t offset,
std::size_t length,
int64* to,
std::size_t toOffset);
/**
* Convert a PV array to a ubyte array.
* @param pv a PV
@@ -472,8 +499,11 @@ public:
* @return number of elements converted
* @throws std::invalid_argument if the element type is not numeric
*/
std::size_t toUByteArray(PVScalarArrayPtr const & pv, std::size_t offset, std::size_t length,
uint8* to, std::size_t toOffset);
std::size_t toUByteArray(PVScalarArrayPtr const & pv,
std::size_t offset,
std::size_t length,
uint8* to,
std::size_t toOffset);
/**
* Convert a PV array to a ushort array.
* @param pv a PV
@@ -484,8 +514,11 @@ public:
* @return number of elements converted
* @throws std::invalid_argument if the element type is not numeric
*/
std::size_t toUShortArray(PVScalarArrayPtr const & pv, std::size_t offset, std::size_t length,
uint16* to, std::size_t toOffset);
std::size_t toUShortArray(PVScalarArrayPtr const & pv,
std::size_t offset,
std::size_t length,
uint16* to,
std::size_t toOffset);
/**
* Convert a PV array to an uint array.
* @param pv a PV
@@ -496,8 +529,12 @@ public:
* @return number of elements converted
* @throws std::invalid_argument if the element type is not numeric
*/
std::size_t toUIntArray(PVScalarArrayPtr const & pv, std::size_t offset, std::size_t length,
uint32* to, std::size_t toOffset);
std::size_t toUIntArray(
PVScalarArrayPtr const & pv,
std::size_t offset,
std::size_t length,
uint32* to,
std::size_t toOffset);
/**
* Convert a PV array to a ulong array.
* @param pv a PV
@@ -508,8 +545,12 @@ public:
* @return number of elements converted
* @throws std::invalid_argument if the element type is not numeric
*/
std::size_t toULongArray(PVScalarArrayPtr const & pv, std::size_t offset, std::size_t length,
uint64* to, std::size_t toOffset);
std::size_t toULongArray(
PVScalarArrayPtr const & pv,
std::size_t offset,
std::size_t length,
uint64* to,
std::size_t toOffset);
/**
* Convert a PV array to a float array.
* @param pv a PV
@@ -520,8 +561,12 @@ public:
* @return number of elements converted
* @throws std::invalid_argument if the element type is not numeric
*/
std::size_t toFloatArray(PVScalarArrayPtr const & pv, std::size_t offset, std::size_t length,
float* to, std::size_t toOffset);
std::size_t toFloatArray(
PVScalarArrayPtr const & pv,
std::size_t offset,
std::size_t length,
float* to,
std::size_t toOffset);
/**
* Convert a PV array to a double array.
* @param pv a PV
@@ -532,8 +577,12 @@ public:
* @return number of elements converted
* @throws std::invalid_argument if the element type is not numeric
*/
std::size_t toDoubleArray(PVScalarArrayPtr const & pv, std::size_t offset, std::size_t length,
double* to, std::size_t toOffset);
std::size_t toDoubleArray(
PVScalarArrayPtr const & pv,
std::size_t offset,
std::size_t length,
double* to, std::size_t
toOffset);
/**
* Convert a PV array from a byte array.
* @param pv a PV
@@ -545,10 +594,10 @@ public:
* @throws std::invalid_argument if the element type is not numeric
*/
std::size_t fromByteArray(
PVScalarArrayPtr const & pv, std::size_t offset, std::size_t length,
PVScalarArrayPtr & pv, std::size_t offset, std::size_t length,
const int8* from, std::size_t fromOffset);
std::size_t fromByteArray(
PVScalarArrayPtr const & pv, std::size_t offset, std::size_t length,
PVScalarArrayPtr & pv, std::size_t offset, std::size_t length,
const ByteArray & from, std::size_t fromOffset);
/**
* Convert a PV array from a short array.
@@ -561,10 +610,10 @@ public:
* @throws std::invalid_argument if the element type is not numeric
*/
std::size_t fromShortArray(
PVScalarArrayPtr const & pv, std::size_t offset, std::size_t length,
PVScalarArrayPtr & pv, std::size_t offset, std::size_t length,
const int16* from, std::size_t fromOffset);
std::size_t fromShortArray(
PVScalarArrayPtr const & pv, std::size_t offset, std::size_t length,
PVScalarArrayPtr & pv, std::size_t offset, std::size_t length,
const ShortArray & from, std::size_t fromOffset);
/**
* Convert a PV array from an int array.
@@ -577,10 +626,10 @@ public:
* @throws std::invalid_argument if the element type is not numeric
*/
std::size_t fromIntArray(
PVScalarArrayPtr const & pv, std::size_t offset, std::size_t length,
PVScalarArrayPtr & pv, std::size_t offset, std::size_t length,
const int32* from, std::size_t fromOffset);
std::size_t fromIntArray(
PVScalarArrayPtr const & pv, std::size_t offset, std::size_t length,
PVScalarArrayPtr & pv, std::size_t offset, std::size_t length,
const IntArray & from, std::size_t fromOffset);
/**
* Convert a PV array from a long array.
@@ -593,10 +642,10 @@ public:
* @throws std::invalid_argument if the element type is not numeric
*/
std::size_t fromLongArray(
PVScalarArrayPtr const & pv, std::size_t offset, std::size_t length,
PVScalarArrayPtr & pv, std::size_t offset, std::size_t length,
const int64* from, std::size_t fromOffset);
std::size_t fromLongArray(
PVScalarArrayPtr const & pv, std::size_t offset, std::size_t length,
PVScalarArrayPtr & pv, std::size_t offset, std::size_t length,
const LongArray & from, std::size_t fromOffset);
/**
* Convert a PV array from a ubyte array.
@@ -609,10 +658,10 @@ public:
* @throws std::invalid_argument if the element type is not numeric
*/
std::size_t fromUByteArray(
PVScalarArrayPtr const & pv, std::size_t offset, std::size_t length,
PVScalarArrayPtr & pv, std::size_t offset, std::size_t length,
const uint8* from, std::size_t fromOffset);
std::size_t fromUByteArray(
PVScalarArrayPtr const & pv, std::size_t offset, std::size_t length,
PVScalarArrayPtr & pv, std::size_t offset, std::size_t length,
const UByteArray & from, std::size_t fromOffset);
/**
* Convert a PV array from a ushort array.
@@ -625,10 +674,10 @@ public:
* @throws std::invalid_argument if the element type is not numeric
*/
std::size_t fromUShortArray(
PVScalarArrayPtr const & pv, std::size_t offset, std::size_t length,
PVScalarArrayPtr & pv, std::size_t offset, std::size_t length,
const uint16* from, std::size_t fromOffset);
std::size_t fromUShortArray(
PVScalarArrayPtr const & pv, std::size_t offset, std::size_t length,
PVScalarArrayPtr & pv, std::size_t offset, std::size_t length,
const UShortArray & from, std::size_t fromOffset);
/**
* Convert a PV array from an uint array.
@@ -641,10 +690,10 @@ public:
* @throws std::invalid_argument if the element type is not numeric
*/
std::size_t fromUIntArray(
PVScalarArrayPtr const & pv, std::size_t offset, std::size_t length,
PVScalarArrayPtr & pv, std::size_t offset, std::size_t length,
const uint32* from, std::size_t fromOffset);
std::size_t fromUIntArray(
PVScalarArrayPtr const & pv, std::size_t offset, std::size_t length,
PVScalarArrayPtr & pv, std::size_t offset, std::size_t length,
const UIntArray & from, std::size_t fromOffset);
/**
* Convert a PV array from a ulong array.
@@ -657,10 +706,10 @@ public:
* @throws std::invalid_argument if the element type is not numeric
*/
std::size_t fromULongArray(
PVScalarArrayPtr const & pv, std::size_t offset, std::size_t length,
PVScalarArrayPtr & pv, std::size_t offset, std::size_t length,
const uint64* from, std::size_t fromOffset);
std::size_t fromULongArray(
PVScalarArrayPtr const & pv, std::size_t offset, std::size_t length,
PVScalarArrayPtr & pv, std::size_t offset, std::size_t length,
const ULongArray & from, std::size_t fromOffset);
/**
* Convert a PV array from a float array.
@@ -673,10 +722,10 @@ public:
* @throws std::invalid_argument if the element type is not numeric
*/
std::size_t fromFloatArray(
PVScalarArrayPtr const & pv, std::size_t offset, std::size_t length,
PVScalarArrayPtr & pv, std::size_t offset, std::size_t length,
const float* from, std::size_t fromOffset);
std::size_t fromFloatArray(
PVScalarArrayPtr const & pv, std::size_t offset, std::size_t length,
PVScalarArrayPtr & pv, std::size_t offset, std::size_t length,
const FloatArray & from, std::size_t fromOffset);
/**
* Convert a PV array from a double array.
@@ -689,10 +738,10 @@ public:
* @throws std::invalid_argument if the element type is not numeric
*/
std::size_t fromDoubleArray(
PVScalarArrayPtr const & pv, std::size_t offset, std::size_t length,
PVScalarArrayPtr & pv, std::size_t offset, std::size_t length,
const double* from, std::size_t fromOffset);
std::size_t fromDoubleArray(
PVScalarArrayPtr const & pv, std::size_t offset, std::size_t length,
PVScalarArrayPtr & pv, std::size_t offset, std::size_t length,
const DoubleArray & from, std::size_t fromOffset);
/**
* Convenience method for implementing toString.

74
pvDataApp/pv/pvData.h
View File

@@ -161,7 +161,7 @@ public:
* Get the fieldName for this field.
* @return The name or empty string if top level field.
*/
String getFieldName();
String getFieldName() const ;
/**
* Register the message requester.
* At most one requester can be registered.
@@ -176,19 +176,19 @@ public:
* The other offsets are determined by recursively traversing each structure of the tree.
* @return The offset.
*/
std::size_t getFieldOffset() ;
std::size_t getFieldOffset() const;
/**
* Get the next offset. If the field is a scalar or array field then this is just offset + 1.
* If the field is a structure it is the offset of the next field after this structure.
* Thus (nextOffset - offset) is always equal to the number of fields within the field.
* @return The offset.
*/
std::size_t getNextFieldOffset() ;
std::size_t getNextFieldOffset() const;
/**
* Get the total number of fields in this field.
* This is equal to nextFieldOffset - fieldOffset.
*/
std::size_t getNumberFields() ;
std::size_t getNumberFields() const;
/**
* Get the PVAuxInfo interface for the PVField.
* @return The PVAuxInfo interface.
@@ -198,7 +198,7 @@ public:
* Is the field immutable, i.e. does it not allow changes.
* @return (false,true) if it (is not, is) immutable.
*/
bool isImmutable() ;
bool isImmutable() const;
/**
* Set the field to be immutable, i. e. it can no longer be modified.
* This is permanent, i.e. once done the field can onot be made mutable.
@@ -208,17 +208,17 @@ public:
* Get the <i>Field</i> that describes the field.
* @return Field, which is the reflection interface.
*/
FieldConstPtr & getField() ;
const FieldConstPtr & getField() const ;
/**
* Get the parent of this field.
* @return The parent interface or null if this is PVRecord
*/
PVStructure * getParent() ;
PVStructure * getParent() const ;
/**
* Replace the data implementation for the field.
* @param newPVField The new implementation
*/
void replacePVField(PVFieldPtr& newPVField);
void replacePVField(const PVFieldPtr& newPVField);
/**
* Rename the field name.
* @param newName The new name.
@@ -258,8 +258,8 @@ protected:
void replaceField(FieldConstPtr &field);
private:
void message(String fieldName,String message,MessageType messageType);
static void computeOffset(PVField *pvField);
static void computeOffset(PVField *pvField,std::size_t offset);
static void computeOffset(const PVField *pvField);
static void computeOffset(const PVField *pvField,std::size_t offset);
PVAuxInfoPtr pvAuxInfo;
String fieldName;
PVStructure *parent;
@@ -290,7 +290,7 @@ public:
* Get the Scalar introspection interface for the PVScalar.
* @return the interface.
*/
ScalarConstPtr getScalar() ;
const ScalarConstPtr getScalar() const ;
protected:
PVScalar(ScalarConstPtr const & scalar);
};
@@ -313,7 +313,7 @@ public:
* Get the value.
* @return The value.
*/
virtual T get() = 0;
virtual T get() const = 0;
/**
* Put a new value into the PVScalar.
* @param The value.
@@ -397,7 +397,7 @@ public:
* Can the capacity be changed.
* @return (false,true) if (can not, can) be changed.
*/
bool isCapacityMutable();
bool isCapacityMutable() const;
/**
* Set the mutability of the array capacity.
* @return false or true
@@ -458,7 +458,7 @@ public:
* Get the introspection interface
* @return The interface.
*/
ScalarArrayConstPtr getScalarArray() ;
const ScalarArrayConstPtr getScalarArray() const ;
protected:
PVScalarArray(ScalarArrayConstPtr const & scalarArray);
@@ -495,7 +495,7 @@ public:
* Get the introspection interface
* @return The interface.
*/
virtual StructureArrayConstPtr getStructureArray();
virtual StructureArrayConstPtr getStructureArray() const ;
/**
* Append new elements to the end of the array.
* @param number The number of elements to add.
@@ -574,24 +574,24 @@ public:
* Get the introspection interface
* @return The interface.
*/
StructureConstPtr & getStructure();
StructureConstPtr getStructure() const;
/**
* Get the array of pointers to the subfields in the structure.
* @return The array.
*/
PVFieldPtrArray & getPVFields();
const PVFieldPtrArray & getPVFields() const;
/**
* Get the subfield with the specified name.
* @param fieldName The name of the field.
* @return Pointer to the field or null if field does not exist.
*/
PVFieldPtr getSubField(String fieldName);
PVFieldPtr getSubField(String fieldName) const;
/**
* Get the subfield with the specified offset.
* @param fieldOffset The offset.
* @return Pointer to the field or null if field does not exist.
*/
PVFieldPtr getSubField(std::size_t fieldOffset);
PVFieldPtr getSubField(std::size_t fieldOffset) const;
/**
* Append a field to the structure.
* @param fieldName The name of the field to append.
@@ -615,79 +615,79 @@ public:
* @param fieldName The name of the field to get.
* @return Pointer to the field of null if a field with that name and type does not exist.
*/
PVBooleanPtr getBooleanField(String fieldName);
PVBooleanPtr getBooleanField(String fieldName) ;
/**
* Get a byte field with the specified name.
* @param fieldName The name of the field to get.
* @return Pointer to the field of null if a field with that name and type does not exist.
*/
PVBytePtr getByteField(String fieldName);
PVBytePtr getByteField(String fieldName) ;
/**
* Get a short field with the specified name.
* @param fieldName The name of the field to get.
* @return Pointer to the field of null if a field with that name and type does not exist.
*/
PVShortPtr getShortField(String fieldName);
PVShortPtr getShortField(String fieldName) ;
/**
* Get a int field with the specified name.
* @param fieldName The name of the field to get.
* @return Pointer to the field of null if a field with that name and type does not exist.
*/
PVIntPtr getIntField(String fieldName);
PVIntPtr getIntField(String fieldName) ;
/**
* Get a long field with the specified name.
* @param fieldName The name of the field to get.
* @return Pointer to the field of null if a field with that name and type does not exist.
*/
PVLongPtr getLongField(String fieldName);
PVLongPtr getLongField(String fieldName) ;
/**
* Get an unsigned byte field with the specified name.
* @param fieldName The name of the field to get.
* @return Pointer to the field of null if a field with that name and type does not exist.
*/
PVUBytePtr getUByteField(String fieldName);
PVUBytePtr getUByteField(String fieldName) ;
/**
* Get an unsigned short field with the specified name.
* @param fieldName The name of the field to get.
* @return Pointer to the field of null if a field with that name and type does not exist.
*/
PVUShortPtr getUShortField(String fieldName);
PVUShortPtr getUShortField(String fieldName) ;
/**
* Get an unsigned int field with the specified name.
* @param fieldName The name of the field to get.
* @return Pointer to the field of null if a field with that name and type does not exist.
*/
PVUIntPtr getUIntField(String fieldName);
PVUIntPtr getUIntField(String fieldName) ;
/**
* Get an unsigned long field with the specified name.
* @param fieldName The name of the field to get.
* @return Pointer to the field of null if a field with that name and type does not exist.
*/
PVULongPtr getULongField(String fieldName);
PVULongPtr getULongField(String fieldName) ;
/**
* Get a float field with the specified name.
* @param fieldName The name of the field to get.
* @return Pointer to the field of null if a field with that name and type does not exist.
*/
PVFloatPtr getFloatField(String fieldName);
PVFloatPtr getFloatField(String fieldName) ;
/**
* Get a double field with the specified name.
* @param fieldName The name of the field to get.
* @return Pointer to the field of null if a field with that name and type does not exist.
*/
PVDoublePtr getDoubleField(String fieldName);
PVDoublePtr getDoubleField(String fieldName) ;
/**
* Get a string field with the specified name.
* @param fieldName The name of the field to get.
* @return Pointer to the field of null if a field with that name and type does not exist.
*/
PVStringPtr getStringField(String fieldName);
PVStringPtr getStringField(String fieldName) ;
/**
* Get a structure field with the specified name.
* @param fieldName The name of the field to get.
* @return Pointer to the field of null if a field with that name and type does not exist.
*/
PVStructurePtr getStructureField(String fieldName);
PVStructurePtr getStructureField(String fieldName) ;
/**
* Get a scalarArray field with the specified name.
* @param fieldName The name of the field to get.
@@ -695,18 +695,18 @@ public:
* @return Pointer to the field of null if a field with that name and type does not exist.
*/
PVScalarArrayPtr getScalarArrayField(
String fieldName,ScalarType elementType);
String fieldName,ScalarType elementType) ;
/**
* Get a structureArray field with the specified name.
* @param fieldName The name of the field to get.
* @return Pointer to the field of null if a field with that name and type does not exist.
*/
PVStructureArrayPtr getStructureArrayField(String fieldName);
PVStructureArrayPtr getStructureArrayField(String fieldName) ;
/**
* Get the name if this structure extends another structure.
* @return The string which may be null.
*/
String getExtendsStructureName();
String getExtendsStructureName() const;
/**
* Put the extends name.
* @param extendsStructureName The name.
@@ -732,7 +732,7 @@ public:
* @param pbuffer The byte buffer.
* @param pflusher Interface to call when buffer is full.
* @param pbitSet A bitset the specifies which fields to serialize.
*/
*/
virtual void serialize(ByteBuffer *pbuffer,
SerializableControl *pflusher,BitSet *pbitSet) const;
/**
@@ -755,7 +755,7 @@ public:
*/
PVStructure(StructureConstPtr const & structure,PVFieldPtrArray const & pvFields);
private:
PVFieldPtrArray pvFields;
const PVFieldPtrArray pvFields;
StructureConstPtr structurePtr;
String extendsStructureName;
friend class PVDataCreate;

5
testApp/pv/testPVAppend.cpp
View File

@@ -66,6 +66,7 @@ static void checkNameAndParent(
static void testAppendSimple(FILE * fd)
{
printf("\ntestAppendSimple\n");
PVFieldPtrArray fields;
StringArray names;
PVStructurePtr pvParent = pvDataCreate->createPVStructure(names,fields);
@@ -86,6 +87,7 @@ static void testAppendSimple(FILE * fd)
static void testAppendMore(FILE * fd)
{
printf("\ntestAppendMore\n");
PVFieldPtrArray fields;
StringArray names;
PVStructurePtr pvStructure = pvDataCreate->createPVStructure(names,fields);
@@ -111,7 +113,7 @@ static void testAppendMore(FILE * fd)
checkNameAndParent(fd,pvStructure,0);
}
static void append2(PVStructurePtr pvStructure,
static void append2(PVStructurePtr &pvStructure,
const char *oneName,const char *twoName,
const char *oneValue,const char *twoValue)
{
@@ -133,6 +135,7 @@ static void append2(PVStructurePtr pvStructure,
}
static void testAppends(FILE * fd)
{
printf("\ntestAppends\n");
PVFieldPtrArray emptyPVFields;
StringArray emptyNames;
PVFieldPtrArray pvFields;