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

serialization added

Browse Source
This commit is contained in:
Matej Sekoranja
2010-11-01 23:28:03 +01:00
parent 304a9c60d0
commit f751d075c5
23 changed files with 1417 additions and 329 deletions
Download Patch File Download Diff File Expand all files Collapse all files

26
pvDataApp/factory/BasePVBoolean.h
View File

@@ -9,6 +9,7 @@
#include "convert.h"
#include "factory.h"
#include "AbstractPVField.h"
#include "byteBuffer.h"
namespace epics { namespace pvData {
@@ -21,13 +22,13 @@ namespace epics { namespace pvData {
virtual bool get();
virtual void put(bool val);
virtual void serialize(ByteBuffer *pbuffer,
SerializableControl *pflusher) ;
SerializableControl *pflusher);
virtual void deserialize(ByteBuffer *pbuffer,
DeserializableControl *pflusher);
virtual void toString(StringBuilder buf);
virtual void toString(StringBuilder buf,int indentLevel);
virtual bool operator==(PVField *pv) ;
virtual bool operator!=(PVField *pv) ;
virtual bool operator==(PVField& pv) ;
virtual bool operator!=(PVField& pv) ;
private:
bool value;
};
@@ -43,33 +44,34 @@ namespace epics { namespace pvData {
void BasePVBoolean::put(bool val){value = val;}
void BasePVBoolean::serialize(ByteBuffer *pbuffer,
SerializableControl *pflusher)
{
throw std::logic_error(notImplemented);
SerializableControl *pflusher) {
pflusher->ensureBuffer(1);
pbuffer->putBoolean(value);
}
void BasePVBoolean::deserialize(ByteBuffer *pbuffer,
DeserializableControl *pflusher)
{
throw std::logic_error(notImplemented);
pflusher->ensureData(1);
value = pbuffer->getBoolean();
}
void BasePVBoolean::toString(StringBuilder buf) {toString(buf,0);}
void BasePVBoolean::toString(StringBuilder buf,int indentLevel)
void BasePVBoolean::toString(StringBuilder buf,int indentLevel)
{
getConvert()->getString(buf,this,indentLevel);
PVField::toString(buf,indentLevel);
}
bool BasePVBoolean::operator==(PVField *pvField)
bool BasePVBoolean::operator==(PVField& pvField)
{
return getConvert()->equals(this,pvField);
return getConvert()->equals(this, &pvField);
}
bool BasePVBoolean::operator!=(PVField *pvField)
bool BasePVBoolean::operator!=(PVField& pvField)
{
return !(getConvert()->equals(this,pvField));
return !(getConvert()->equals(this, &pvField));
}
}}

82
pvDataApp/factory/BasePVBooleanArray.h
View File

@@ -5,10 +5,14 @@
#include <cstdlib>
#include <string>
#include <cstdio>
#include <algorithm>
#include <epicsTypes.h>
#include "pvData.h"
#include "factory.h"
#include "AbstractPVScalarArray.h"
#include "serializeHelper.h"
using std::min;
namespace epics { namespace pvData {
@@ -33,8 +37,8 @@ namespace epics { namespace pvData {
SerializableControl *pflusher, int offset, int count) ;
virtual void toString(StringBuilder buf);
virtual void toString(StringBuilder buf,int indentLevel);
virtual bool operator==(PVField *pv) ;
virtual bool operator!=(PVField *pv) ;
virtual bool operator==(PVField& pv) ;
virtual bool operator!=(PVField& pv) ;
private:
bool *value;
};
@@ -42,7 +46,7 @@ namespace epics { namespace pvData {
BasePVBooleanArray::BasePVBooleanArray(PVStructure *parent,
ScalarArrayConstPtr scalarArray)
: PVBooleanArray(parent,scalarArray),value(new bool[0])
{ }
{ }
BasePVBooleanArray::~BasePVBooleanArray()
{
@@ -59,14 +63,14 @@ namespace epics { namespace pvData {
}
int length = PVArray::getLength();
if(length>capacity) length = capacity;
bool *newValue = new bool[capacity];
bool *newValue = new bool[capacity];
for(int i=0; i<length; i++) newValue[i] = value[i];
delete[]value;
value = newValue;
PVArray::setCapacityLength(capacity,length);
}
int BasePVBooleanArray::get(int offset, int len, BooleanArrayData *data)
int BasePVBooleanArray::get(int offset, int len, BooleanArrayData *data)
{
int n = len;
int length = PVArray::getLength();
@@ -105,7 +109,7 @@ namespace epics { namespace pvData {
}
PVArray::setLength(length);
PVField::postPut();
return len;
return len;
}
void BasePVBooleanArray::shareData(BooleanArray shareValue,int capacity,int length)
@@ -116,21 +120,61 @@ namespace epics { namespace pvData {
}
void BasePVBooleanArray::serialize(ByteBuffer *pbuffer,
SerializableControl *pflusher)
{
throw std::logic_error(notImplemented);
SerializableControl *pflusher) {
serialize(pbuffer, pflusher, 0, getLength());
}
void BasePVBooleanArray::deserialize(ByteBuffer *pbuffer,
DeserializableControl *pflusher)
{
throw std::logic_error(notImplemented);
DeserializableControl *pcontrol) {
int size = SerializeHelper::readSize(pbuffer, pcontrol);
if(size>=0) {
// prepare array, if necessary
if(size>getCapacity()) setCapacity(size);
// retrieve value from the buffer
int i = 0;
while(true) {
int maxIndex = min(size-i, pbuffer->getRemaining())+i;
for(; i<maxIndex; i++)
value[i] = pbuffer->getBoolean();
if(i<size)
pcontrol->ensureData(1); // // TODO is there a better way to ensureData?
else
break;
}
// set new length
setLength(size);
postPut();
}
// TODO null arrays (size == -1) not supported
}
void BasePVBooleanArray::serialize(ByteBuffer *pbuffer,
SerializableControl *pflusher, int offset, int count)
{
throw std::logic_error(notImplemented);
SerializableControl *pflusher, int offset, int count) {
// cache
int length = getLength();
// check bounds
if(offset<0)
offset = 0;
else if(offset>length) offset = length;
if(count<0) count = length;
int maxCount = length-offset;
if(count>maxCount) count = maxCount;
// write
SerializeHelper::writeSize(count, pbuffer, pflusher);
int end = offset+count;
int i = offset;
while(true) {
int maxIndex = min(end-i, pbuffer->getRemaining())+i;
for(; i<maxIndex; i++)
pbuffer->putBoolean(value[i]);
if(i<end)
pflusher->flushSerializeBuffer();
else
break;
}
}
void BasePVBooleanArray::toString(StringBuilder buf)
@@ -145,14 +189,14 @@ namespace epics { namespace pvData {
PVField::toString(buf,indentLevel);
}
bool BasePVBooleanArray::operator==(PVField *pv)
bool BasePVBooleanArray::operator==(PVField& pv)
{
return getConvert()->equals(this,pv);
return getConvert()->equals(this, &pv);
}
bool BasePVBooleanArray::operator!=(PVField *pv)
bool BasePVBooleanArray::operator!=(PVField& pv)
{
return !(getConvert()->equals(this,pv));
return !(getConvert()->equals(this, &pv));
}
}}
#endif /* BASEPVBOOLEANARRAY_H */

29
pvDataApp/factory/BasePVByte.h
View File

@@ -9,6 +9,7 @@
#include "convert.h"
#include "factory.h"
#include "AbstractPVField.h"
#include "byteBuffer.h"
namespace epics { namespace pvData {
@@ -26,14 +27,14 @@ namespace epics { namespace pvData {
DeserializableControl *pflusher);
virtual void toString(StringBuilder buf);
virtual void toString(StringBuilder buf,int indentLevel);
virtual bool operator==(PVField *pv) ;
virtual bool operator!=(PVField *pv) ;
virtual bool operator==(PVField& pv) ;
virtual bool operator!=(PVField& pv) ;
private:
epicsInt8 value;
};
BasePVByte::BasePVByte(PVStructure *parent,ScalarConstPtr scalar)
: PVByte(parent,scalar),value(0.0)
: PVByte(parent,scalar),value(0)
{}
BasePVByte::~BasePVByte() {}
@@ -43,33 +44,33 @@ namespace epics { namespace pvData {
void BasePVByte::put(epicsInt8 val){value = val;}
void BasePVByte::serialize(ByteBuffer *pbuffer,
SerializableControl *pflusher)
{
throw std::logic_error(notImplemented);
SerializableControl *pflusher) {
pflusher->ensureBuffer(1);
pbuffer->putByte(value);
}
void BasePVByte::deserialize(ByteBuffer *pbuffer,
DeserializableControl *pflusher)
{
throw std::logic_error(notImplemented);
DeserializableControl *pflusher) {
pflusher->ensureData(1);
value = pbuffer->getByte();
}
void BasePVByte::toString(StringBuilder buf) {toString(buf,0);}
void BasePVByte::toString(StringBuilder buf,int indentLevel)
void BasePVByte::toString(StringBuilder buf,int indentLevel)
{
getConvert()->getString(buf,this,indentLevel);
PVField::toString(buf,indentLevel);
}
bool BasePVByte::operator==(PVField *pvField)
bool BasePVByte::operator==(PVField& pvField)
{
return getConvert()->equals(this,pvField);
return getConvert()->equals(this, &pvField);
}
bool BasePVByte::operator!=(PVField *pvField)
bool BasePVByte::operator!=(PVField& pvField)
{
return !(getConvert()->equals(this,pvField));
return !(getConvert()->equals(this, &pvField));
}
}}

82
pvDataApp/factory/BasePVByteArray.h
View File

@@ -5,10 +5,14 @@
#include <cstdlib>
#include <string>
#include <cstdio>
#include <algorithm>
#include <epicsTypes.h>
#include "pvData.h"
#include "factory.h"
#include "AbstractPVScalarArray.h"
#include "serializeHelper.h"
using std::min;
namespace epics { namespace pvData {
@@ -33,8 +37,8 @@ namespace epics { namespace pvData {
SerializableControl *pflusher, int offset, int count) ;
virtual void toString(StringBuilder buf);
virtual void toString(StringBuilder buf,int indentLevel);
virtual bool operator==(PVField *pv) ;
virtual bool operator!=(PVField *pv) ;
virtual bool operator==(PVField& pv) ;
virtual bool operator!=(PVField& pv) ;
private:
epicsInt8 *value;
};
@@ -42,7 +46,7 @@ namespace epics { namespace pvData {
BasePVByteArray::BasePVByteArray(PVStructure *parent,
ScalarArrayConstPtr scalarArray)
: PVByteArray(parent,scalarArray),value(new epicsInt8[0])
{ }
{ }
BasePVByteArray::~BasePVByteArray()
{
@@ -59,14 +63,14 @@ namespace epics { namespace pvData {
}
int length = PVArray::getLength();
if(length>capacity) length = capacity;
epicsInt8 *newValue = new epicsInt8[capacity];
epicsInt8 *newValue = new epicsInt8[capacity];
for(int i=0; i<length; i++) newValue[i] = value[i];
delete[]value;
value = newValue;
PVArray::setCapacityLength(capacity,length);
}
int BasePVByteArray::get(int offset, int len, ByteArrayData *data)
int BasePVByteArray::get(int offset, int len, ByteArrayData *data)
{
int n = len;
int length = PVArray::getLength();
@@ -105,7 +109,7 @@ namespace epics { namespace pvData {
}
PVArray::setLength(length);
PVField::postPut();
return len;
return len;
}
void BasePVByteArray::shareData(ByteArray shareValue,int capacity,int length)
@@ -116,21 +120,61 @@ namespace epics { namespace pvData {
}
void BasePVByteArray::serialize(ByteBuffer *pbuffer,
SerializableControl *pflusher)
{
throw std::logic_error(notImplemented);
SerializableControl *pflusher) {
serialize(pbuffer, pflusher, 0, getLength());
}
void BasePVByteArray::deserialize(ByteBuffer *pbuffer,
DeserializableControl *pflusher)
{
throw std::logic_error(notImplemented);
DeserializableControl *pcontrol) {
int size = SerializeHelper::readSize(pbuffer, pcontrol);
if(size>=0) {
// prepare array, if necessary
if(size>getCapacity()) setCapacity(size);
// retrieve value from the buffer
int i = 0;
while(true) {
int toRead = min(size-i, pbuffer->getRemaining());
pbuffer->get(value, i, toRead);
i += toRead;
if(i<size)
pcontrol->ensureData(1); // TODO: is there a better way to ensureData?
else
break;
}
// set new length
setLength(size);
postPut();
}
// TODO null arrays (size == -1) not supported
}
void BasePVByteArray::serialize(ByteBuffer *pbuffer,
SerializableControl *pflusher, int offset, int count)
{
throw std::logic_error(notImplemented);
SerializableControl *pflusher, int offset, int count) {
// cache
int length = getLength();
// check bounds
if(offset<0)
offset = 0;
else if(offset>length) offset = length;
if(count<0) count = length;
int maxCount = length-offset;
if(count>maxCount) count = maxCount;
// write
SerializeHelper::writeSize(count, pbuffer, pflusher);
int end = offset+count;
int i = offset;
while(true) {
int maxIndex = min(end-i, pbuffer->getRemaining())+i;
for(; i<maxIndex; i++)
pbuffer->putByte(value[i]);
if(i<end)
pflusher->flushSerializeBuffer();
else
break;
}
}
void BasePVByteArray::toString(StringBuilder buf)
@@ -145,14 +189,14 @@ namespace epics { namespace pvData {
PVField::toString(buf,indentLevel);
}
bool BasePVByteArray::operator==(PVField *pv)
bool BasePVByteArray::operator==(PVField& pv)
{
return getConvert()->equals(this,pv);
return getConvert()->equals(this, &pv);
}
bool BasePVByteArray::operator!=(PVField *pv)
bool BasePVByteArray::operator!=(PVField& pv)
{
return !(getConvert()->equals(this,pv));
return !(getConvert()->equals(this, &pv));
}
}}
#endif /* BASEPVBYTEARRAY_H */

27
pvDataApp/factory/BasePVDouble.h
View File

@@ -9,6 +9,7 @@
#include "convert.h"
#include "factory.h"
#include "AbstractPVField.h"
#include "byteBuffer.h"
namespace epics { namespace pvData {
@@ -26,8 +27,8 @@ namespace epics { namespace pvData {
DeserializableControl *pflusher);
virtual void toString(StringBuilder buf);
virtual void toString(StringBuilder buf,int indentLevel);
virtual bool operator==(PVField *pv) ;
virtual bool operator!=(PVField *pv) ;
virtual bool operator==(PVField& pv) ;
virtual bool operator!=(PVField& pv) ;
private:
double value;
};
@@ -43,33 +44,33 @@ namespace epics { namespace pvData {
void BasePVDouble::put(double val){value = val;}
void BasePVDouble::serialize(ByteBuffer *pbuffer,
SerializableControl *pflusher)
{
throw std::logic_error(notImplemented);
SerializableControl *pflusher) {
pflusher->ensureBuffer(sizeof(double));
pbuffer->putDouble(value);
}
void BasePVDouble::deserialize(ByteBuffer *pbuffer,
DeserializableControl *pflusher)
{
throw std::logic_error(notImplemented);
DeserializableControl *pflusher) {
pflusher->ensureData(sizeof(double));
value = pbuffer->getDouble();
}
void BasePVDouble::toString(StringBuilder buf) {toString(buf,0);}
void BasePVDouble::toString(StringBuilder buf,int indentLevel)
void BasePVDouble::toString(StringBuilder buf,int indentLevel)
{
getConvert()->getString(buf,this,indentLevel);
PVField::toString(buf,indentLevel);
}
bool BasePVDouble::operator==(PVField *pvField)
bool BasePVDouble::operator==(PVField& pvField)
{
return getConvert()->equals(this,pvField);
return getConvert()->equals(this, &pvField);
}
bool BasePVDouble::operator!=(PVField *pvField)
bool BasePVDouble::operator!=(PVField& pvField)
{
return !(getConvert()->equals(this,pvField));
return !(getConvert()->equals(this, &pvField));
}
}}

84
pvDataApp/factory/BasePVDoubleArray.h
View File

@@ -5,10 +5,14 @@
#include <cstdlib>
#include <string>
#include <cstdio>
#include <algorithm>
#include <epicsTypes.h>
#include "pvData.h"
#include "factory.h"
#include "AbstractPVScalarArray.h"
#include "serializeHelper.h"
using std::min;
namespace epics { namespace pvData {
@@ -33,8 +37,8 @@ namespace epics { namespace pvData {
SerializableControl *pflusher, int offset, int count) ;
virtual void toString(StringBuilder buf);
virtual void toString(StringBuilder buf,int indentLevel);
virtual bool operator==(PVField *pv) ;
virtual bool operator!=(PVField *pv) ;
virtual bool operator==(PVField& pv) ;
virtual bool operator!=(PVField& pv) ;
private:
double *value;
};
@@ -42,7 +46,7 @@ namespace epics { namespace pvData {
BasePVDoubleArray::BasePVDoubleArray(PVStructure *parent,
ScalarArrayConstPtr scalarArray)
: PVDoubleArray(parent,scalarArray),value(new double[0])
{ }
{ }
BasePVDoubleArray::~BasePVDoubleArray()
{
@@ -59,14 +63,14 @@ namespace epics { namespace pvData {
}
int length = PVArray::getLength();
if(length>capacity) length = capacity;
double *newValue = new double[capacity];
double *newValue = new double[capacity];
for(int i=0; i<length; i++) newValue[i] = value[i];
delete[]value;
value = newValue;
setCapacityLength(capacity,length);
}
int BasePVDoubleArray::get(int offset, int len, DoubleArrayData *data)
int BasePVDoubleArray::get(int offset, int len, DoubleArrayData *data)
{
int n = len;
int length = PVArray::getLength();
@@ -105,7 +109,7 @@ namespace epics { namespace pvData {
}
PVArray::setLength(length);
PVField::postPut();
return len;
return len;
}
void BasePVDoubleArray::shareData(
@@ -117,21 +121,63 @@ namespace epics { namespace pvData {
}
void BasePVDoubleArray::serialize(ByteBuffer *pbuffer,
SerializableControl *pflusher)
{
throw std::logic_error(notImplemented);
SerializableControl *pflusher) {
serialize(pbuffer, pflusher, 0, getLength());
}
void BasePVDoubleArray::deserialize(ByteBuffer *pbuffer,
DeserializableControl *pflusher)
{
throw std::logic_error(notImplemented);
DeserializableControl *pcontrol) {
int size = SerializeHelper::readSize(pbuffer, pcontrol);
if(size>=0) {
// prepare array, if necessary
if(size>getCapacity()) setCapacity(size);
// retrieve value from the buffer
int i = 0;
while(true) {
int maxIndex = min(size-i, (int)(pbuffer->getRemaining()
/sizeof(double)))+i;
for(; i<maxIndex; i++)
value[i] = pbuffer->getDouble();
if(i<size)
pcontrol->ensureData(sizeof(double));
else
break;
}
// set new length
setLength(size);
postPut();
}
// TODO null arrays (size == -1) not supported
}
void BasePVDoubleArray::serialize(ByteBuffer *pbuffer,
SerializableControl *pflusher, int offset, int count)
{
throw std::logic_error(notImplemented);
SerializableControl *pflusher, int offset, int count) {
// cache
int length = getLength();
// check bounds
if(offset<0)
offset = 0;
else if(offset>length) offset = length;
if(count<0) count = length;
int maxCount = length-offset;
if(count>maxCount) count = maxCount;
// write
SerializeHelper::writeSize(count, pbuffer, pflusher);
int end = offset+count;
int i = offset;
while(true) {
int maxIndex = min(end-i, (int)(pbuffer->getRemaining()
/sizeof(double)))+i;
for(; i<maxIndex; i++)
pbuffer->putDouble(value[i]);
if(i<end)
pflusher->flushSerializeBuffer();
else
break;
}
}
void BasePVDoubleArray::toString(StringBuilder buf)
@@ -146,14 +192,14 @@ namespace epics { namespace pvData {
PVField::toString(buf,indentLevel);
}
bool BasePVDoubleArray::operator==(PVField *pv)
bool BasePVDoubleArray::operator==(PVField& pv)
{
return getConvert()->equals(this,pv);
return getConvert()->equals(this, &pv);
}
bool BasePVDoubleArray::operator!=(PVField *pv)
bool BasePVDoubleArray::operator!=(PVField& pv)
{
return !(getConvert()->equals(this,pv));
return !(getConvert()->equals(this, &pv));
}
}}
#endif /* BASEPVDOUBLEARRAY_H */

27
pvDataApp/factory/BasePVFloat.h
View File

@@ -9,6 +9,7 @@
#include "convert.h"
#include "factory.h"
#include "AbstractPVField.h"
#include "byteBuffer.h"
namespace epics { namespace pvData {
@@ -26,8 +27,8 @@ namespace epics { namespace pvData {
DeserializableControl *pflusher);
virtual void toString(StringBuilder buf);
virtual void toString(StringBuilder buf,int indentLevel);
virtual bool operator==(PVField *pv) ;
virtual bool operator!=(PVField *pv) ;
virtual bool operator==(PVField& pv) ;
virtual bool operator!=(PVField& pv) ;
private:
float value;
};
@@ -43,33 +44,33 @@ namespace epics { namespace pvData {
void BasePVFloat::put(float val){value = val;}
void BasePVFloat::serialize(ByteBuffer *pbuffer,
SerializableControl *pflusher)
{
throw std::logic_error(notImplemented);
SerializableControl *pflusher) {
pflusher->ensureBuffer(sizeof(float));
pbuffer->putFloat(value);
}
void BasePVFloat::deserialize(ByteBuffer *pbuffer,
DeserializableControl *pflusher)
{
throw std::logic_error(notImplemented);
DeserializableControl *pflusher) {
pflusher->ensureData(sizeof(float));
value = pbuffer->getFloat();
}
void BasePVFloat::toString(StringBuilder buf) {toString(buf,0);}
void BasePVFloat::toString(StringBuilder buf,int indentLevel)
void BasePVFloat::toString(StringBuilder buf,int indentLevel)
{
getConvert()->getString(buf,this,indentLevel);
PVField::toString(buf,indentLevel);
}
bool BasePVFloat::operator==(PVField *pvField)
bool BasePVFloat::operator==(PVField& pvField)
{
return getConvert()->equals(this,pvField);
return getConvert()->equals(this, &pvField);
}
bool BasePVFloat::operator!=(PVField *pvField)
bool BasePVFloat::operator!=(PVField& pvField)
{
return !(getConvert()->equals(this,pvField));
return !(getConvert()->equals(this, &pvField));
}
}}

86
pvDataApp/factory/BasePVFloatArray.h
View File

@@ -5,13 +5,17 @@
#include <cstdlib>
#include <string>
#include <cstdio>
#include <algorithm>
#include <epicsTypes.h>
#include "pvData.h"
#include "factory.h"
#include "AbstractPVScalarArray.h"
#include "serializeHelper.h"
namespace epics { namespace pvData {
using std::min;
PVFloatArray::~PVFloatArray() {}
PVFloatArray::PVFloatArray(PVStructure *parent,ScalarArrayConstPtr scalar)
@@ -33,8 +37,8 @@ namespace epics { namespace pvData {
SerializableControl *pflusher, int offset, int count) ;
virtual void toString(StringBuilder buf);
virtual void toString(StringBuilder buf,int indentLevel);
virtual bool operator==(PVField *pv) ;
virtual bool operator!=(PVField *pv) ;
virtual bool operator==(PVField& pv) ;
virtual bool operator!=(PVField& pv) ;
private:
float *value;
};
@@ -42,7 +46,7 @@ namespace epics { namespace pvData {
BasePVFloatArray::BasePVFloatArray(PVStructure *parent,
ScalarArrayConstPtr scalarArray)
: PVFloatArray(parent,scalarArray),value(new float[0])
{ }
{ }
BasePVFloatArray::~BasePVFloatArray()
{
@@ -59,14 +63,14 @@ namespace epics { namespace pvData {
}
int length = PVArray::getLength();
if(length>capacity) length = capacity;
float *newValue = new float[capacity];
float *newValue = new float[capacity];
for(int i=0; i<length; i++) newValue[i] = value[i];
delete[]value;
value = newValue;
PVArray::setCapacityLength(capacity,length);
}
int BasePVFloatArray::get(int offset, int len, FloatArrayData *data)
int BasePVFloatArray::get(int offset, int len, FloatArrayData *data)
{
int n = len;
int length = PVArray::getLength();
@@ -105,7 +109,7 @@ namespace epics { namespace pvData {
}
PVArray::setLength(length);
PVField::postPut();
return len;
return len;
}
void BasePVFloatArray::shareData(
@@ -116,22 +120,64 @@ namespace epics { namespace pvData {
PVArray::setCapacityLength(capacity,length);
}
void BasePVFloatArray::serialize(ByteBuffer *pbuffer,
SerializableControl *pflusher)
{
throw std::logic_error(notImplemented);
void BasePVFloatArray::serialize(ByteBuffer *pbuffer,
SerializableControl *pflusher) {
serialize(pbuffer, pflusher, 0, getLength());
}
void BasePVFloatArray::deserialize(ByteBuffer *pbuffer,
DeserializableControl *pflusher)
{
throw std::logic_error(notImplemented);
DeserializableControl *pcontrol) {
int size = SerializeHelper::readSize(pbuffer, pcontrol);
if(size>=0) {
// prepare array, if necessary
if(size>getCapacity()) setCapacity(size);
// retrieve value from the buffer
int i = 0;
while(true) {
int maxIndex = min(size-i, (int)(pbuffer->getRemaining()
/sizeof(float)))+i;
for(; i<maxIndex; i++)
value[i] = pbuffer->getFloat();
if(i<size)
pcontrol->ensureData(sizeof(float)); // TODO: is there a better way to ensureData?
else
break;
}
// set new length
setLength(size);
postPut();
}
// TODO null arrays (size == -1) not supported
}
void BasePVFloatArray::serialize(ByteBuffer *pbuffer,
SerializableControl *pflusher, int offset, int count)
{
throw std::logic_error(notImplemented);
SerializableControl *pflusher, int offset, int count) {
// cache
int length = getLength();
// check bounds
if(offset<0)
offset = 0;
else if(offset>length) offset = length;
if(count<0) count = length;
int maxCount = length-offset;
if(count>maxCount) count = maxCount;
// write
SerializeHelper::writeSize(count, pbuffer, pflusher);
int end = offset+count;
int i = offset;
while(true) {
int maxIndex = min(end-i, (int)(pbuffer->getRemaining()
/sizeof(float)))+i;
for(; i<maxIndex; i++)
pbuffer->putFloat(value[i]);
if(i<end)
pflusher->flushSerializeBuffer();
else
break;
}
}
void BasePVFloatArray::toString(StringBuilder buf)
@@ -146,14 +192,14 @@ namespace epics { namespace pvData {
PVField::toString(buf,indentLevel);
}
bool BasePVFloatArray::operator==(PVField *pv)
bool BasePVFloatArray::operator==(PVField& pv)
{
return getConvert()->equals(this,pv);
return getConvert()->equals(this, &pv);
}
bool BasePVFloatArray::operator!=(PVField *pv)
bool BasePVFloatArray::operator!=(PVField& pv)
{
return !(getConvert()->equals(this,pv));
return !(getConvert()->equals(this, &pv));
}
}}
#endif /* BASEPVFLOATARRAY_H */

29
pvDataApp/factory/BasePVInt.h
View File

@@ -9,6 +9,7 @@
#include "convert.h"
#include "factory.h"
#include "AbstractPVField.h"
#include "byteBuffer.h"
namespace epics { namespace pvData {
@@ -26,14 +27,14 @@ namespace epics { namespace pvData {
DeserializableControl *pflusher);
virtual void toString(StringBuilder buf);
virtual void toString(StringBuilder buf,int indentLevel);
virtual bool operator==(PVField *pv) ;
virtual bool operator!=(PVField *pv) ;
virtual bool operator==(PVField& pv) ;
virtual bool operator!=(PVField& pv) ;
private:
epicsInt32 value;
};
BasePVInt::BasePVInt(PVStructure *parent,ScalarConstPtr scalar)
: PVInt(parent,scalar),value(0.0)
: PVInt(parent,scalar),value(0)
{}
BasePVInt::~BasePVInt() {}
@@ -43,33 +44,33 @@ namespace epics { namespace pvData {
void BasePVInt::put(epicsInt32 val){value = val;}
void BasePVInt::serialize(ByteBuffer *pbuffer,
SerializableControl *pflusher)
{
throw std::logic_error(notImplemented);
SerializableControl *pflusher) {
pflusher->ensureBuffer(sizeof(epicsInt32));
pbuffer->putInt(value);
}
void BasePVInt::deserialize(ByteBuffer *pbuffer,
DeserializableControl *pflusher)
{
throw std::logic_error(notImplemented);
DeserializableControl *pflusher) {
pflusher->ensureData(sizeof(epicsInt32));
value = pbuffer->getInt();
}
void BasePVInt::toString(StringBuilder buf) {toString(buf,0);}
void BasePVInt::toString(StringBuilder buf,int indentLevel)
void BasePVInt::toString(StringBuilder buf,int indentLevel)
{
getConvert()->getString(buf,this,indentLevel);
PVField::toString(buf,indentLevel);
}
bool BasePVInt::operator==(PVField *pvField)
bool BasePVInt::operator==(PVField& pvField)
{
return getConvert()->equals(this,pvField);
return getConvert()->equals(this, &pvField);
}
bool BasePVInt::operator!=(PVField *pvField)
bool BasePVInt::operator!=(PVField& pvField)
{
return !(getConvert()->equals(this,pvField));
return !(getConvert()->equals(this, &pvField));
}
}}

84
pvDataApp/factory/BasePVIntArray.h
View File

@@ -5,10 +5,14 @@
#include <cstdlib>
#include <string>
#include <cstdio>
#include <algorithm>
#include <epicsTypes.h>
#include "pvData.h"
#include "factory.h"
#include "AbstractPVScalarArray.h"
#include "serializeHelper.h"
using std::min;
namespace epics { namespace pvData {
@@ -33,8 +37,8 @@ namespace epics { namespace pvData {
SerializableControl *pflusher, int offset, int count) ;
virtual void toString(StringBuilder buf);
virtual void toString(StringBuilder buf,int indentLevel);
virtual bool operator==(PVField *pv) ;
virtual bool operator!=(PVField *pv) ;
virtual bool operator==(PVField& pv) ;
virtual bool operator!=(PVField& pv) ;
private:
epicsInt32 *value;
};
@@ -42,7 +46,7 @@ namespace epics { namespace pvData {
BasePVIntArray::BasePVIntArray(PVStructure *parent,
ScalarArrayConstPtr scalarArray)
: PVIntArray(parent,scalarArray),value(new epicsInt32[0])
{ }
{ }
BasePVIntArray::~BasePVIntArray()
{
@@ -59,14 +63,14 @@ namespace epics { namespace pvData {
}
int length = PVArray::getLength();
if(length>capacity) length = capacity;
epicsInt32 *newValue = new epicsInt32[capacity];
epicsInt32 *newValue = new epicsInt32[capacity];
for(int i=0; i<length; i++) newValue[i] = value[i];
delete[]value;
value = newValue;
PVArray::setCapacityLength(capacity,length);
}
int BasePVIntArray::get(int offset, int len, IntArrayData *data)
int BasePVIntArray::get(int offset, int len, IntArrayData *data)
{
int n = len;
int length = PVArray::getLength();
@@ -105,7 +109,7 @@ namespace epics { namespace pvData {
}
PVArray::setLength(length);
PVField::postPut();
return len;
return len;
}
void BasePVIntArray::shareData(
@@ -117,21 +121,63 @@ namespace epics { namespace pvData {
}
void BasePVIntArray::serialize(ByteBuffer *pbuffer,
SerializableControl *pflusher)
{
throw std::logic_error(notImplemented);
SerializableControl *pflusher) {
serialize(pbuffer, pflusher, 0, getLength());
}
void BasePVIntArray::deserialize(ByteBuffer *pbuffer,
DeserializableControl *pflusher)
{
throw std::logic_error(notImplemented);
DeserializableControl *pcontrol) {
int size = SerializeHelper::readSize(pbuffer, pcontrol);
if(size>=0) {
// prepare array, if necessary
if(size>getCapacity()) setCapacity(size);
// retrieve value from the buffer
int i = 0;
while(true) {
int maxIndex = min(size-i, (int)(pbuffer->getRemaining()
/sizeof(epicsInt32)))+i;
for(; i<maxIndex; i++)
value[i] = pbuffer->getInt();
if(i<size)
pcontrol->ensureData(sizeof(epicsInt32)); // TODO: is there a better way to ensureData?
else
break;
}
// set new length
setLength(size);
postPut();
}
// TODO null arrays (size == -1) not supported
}
void BasePVIntArray::serialize(ByteBuffer *pbuffer,
SerializableControl *pflusher, int offset, int count)
{
throw std::logic_error(notImplemented);
SerializableControl *pflusher, int offset, int count) {
// cache
int length = getLength();
// check bounds
if(offset<0)
offset = 0;
else if(offset>length) offset = length;
if(count<0) count = length;
int maxCount = length-offset;
if(count>maxCount) count = maxCount;
// write
SerializeHelper::writeSize(count, pbuffer, pflusher);
int end = offset+count;
int i = offset;
while(true) {
int maxIndex = min(end-i, (int)(pbuffer->getRemaining()
/sizeof(epicsInt32)))+i;
for(; i<maxIndex; i++)
pbuffer->putInt(value[i]);
if(i<end)
pflusher->flushSerializeBuffer();
else
break;
}
}
void BasePVIntArray::toString(StringBuilder buf)
@@ -146,14 +192,14 @@ namespace epics { namespace pvData {
PVField::toString(buf,indentLevel);
}
bool BasePVIntArray::operator==(PVField *pv)
bool BasePVIntArray::operator==(PVField& pv)
{
return getConvert()->equals(this,pv);
return getConvert()->equals(this, &pv);
}
bool BasePVIntArray::operator!=(PVField *pv)
bool BasePVIntArray::operator!=(PVField& pv)
{
return !(getConvert()->equals(this,pv));
return !(getConvert()->equals(this, &pv));
}
}}
#endif /* BASEPVINTARRAY_H */

29
pvDataApp/factory/BasePVLong.h
View File

@@ -9,6 +9,7 @@
#include "convert.h"
#include "factory.h"
#include "AbstractPVField.h"
#include "byteBuffer.h"
namespace epics { namespace pvData {
@@ -26,14 +27,14 @@ namespace epics { namespace pvData {
DeserializableControl *pflusher);
virtual void toString(StringBuilder buf);
virtual void toString(StringBuilder buf,int indentLevel);
virtual bool operator==(PVField *pv) ;
virtual bool operator!=(PVField *pv) ;
virtual bool operator==(PVField& pv) ;
virtual bool operator!=(PVField& pv) ;
private:
epicsInt64 value;
};
BasePVLong::BasePVLong(PVStructure *parent,ScalarConstPtr scalar)
: PVLong(parent,scalar),value(0.0)
: PVLong(parent,scalar),value(0)
{}
BasePVLong::~BasePVLong() {}
@@ -43,33 +44,33 @@ namespace epics { namespace pvData {
void BasePVLong::put(epicsInt64 val){value = val;}
void BasePVLong::serialize(ByteBuffer *pbuffer,
SerializableControl *pflusher)
{
throw std::logic_error(notImplemented);
SerializableControl *pflusher) {
pflusher->ensureBuffer(sizeof(epicsInt64));
pbuffer->putLong(value);
}
void BasePVLong::deserialize(ByteBuffer *pbuffer,
DeserializableControl *pflusher)
{
throw std::logic_error(notImplemented);
DeserializableControl *pflusher) {
pflusher->ensureData(sizeof(epicsInt64));
value = pbuffer->getLong();
}
void BasePVLong::toString(StringBuilder buf) {toString(buf,0);}
void BasePVLong::toString(StringBuilder buf,int indentLevel)
void BasePVLong::toString(StringBuilder buf,int indentLevel)
{
getConvert()->getString(buf,this,indentLevel);
PVField::toString(buf,indentLevel);
}
bool BasePVLong::operator==(PVField *pvField)
bool BasePVLong::operator==(PVField& pvField)
{
return getConvert()->equals(this,pvField);
return getConvert()->equals(this, &pvField);
}
bool BasePVLong::operator!=(PVField *pvField)
bool BasePVLong::operator!=(PVField& pvField)
{
return !(getConvert()->equals(this,pvField));
return !(getConvert()->equals(this, &pvField));
}
}}

84
pvDataApp/factory/BasePVLongArray.h
View File

@@ -5,10 +5,14 @@
#include <cstdlib>
#include <string>
#include <cstdio>
#include <algorithm>
#include <epicsTypes.h>
#include "pvData.h"
#include "factory.h"
#include "AbstractPVScalarArray.h"
#include "serializeHelper.h"
using std::min;
namespace epics { namespace pvData {
@@ -33,8 +37,8 @@ namespace epics { namespace pvData {
SerializableControl *pflusher, int offset, int count) ;
virtual void toString(StringBuilder buf);
virtual void toString(StringBuilder buf,int indentLevel);
virtual bool operator==(PVField *pv) ;
virtual bool operator!=(PVField *pv) ;
virtual bool operator==(PVField& pv) ;
virtual bool operator!=(PVField& pv) ;
private:
epicsInt64 *value;
};
@@ -42,7 +46,7 @@ namespace epics { namespace pvData {
BasePVLongArray::BasePVLongArray(PVStructure *parent,
ScalarArrayConstPtr scalarArray)
: PVLongArray(parent,scalarArray),value(new epicsInt64[0])
{ }
{ }
BasePVLongArray::~BasePVLongArray()
{
@@ -59,14 +63,14 @@ namespace epics { namespace pvData {
}
int length = PVArray::getLength();
if(length>capacity) length = capacity;
epicsInt64 *newValue = new epicsInt64[capacity];
epicsInt64 *newValue = new epicsInt64[capacity];
for(int i=0; i<length; i++) newValue[i] = value[i];
delete[]value;
value = newValue;
PVArray::setCapacityLength(capacity,length);
}
int BasePVLongArray::get(int offset, int len, LongArrayData *data)
int BasePVLongArray::get(int offset, int len, LongArrayData *data)
{
int n = len;
int length = PVArray::getLength();
@@ -105,7 +109,7 @@ namespace epics { namespace pvData {
}
PVArray::setLength(length);
PVField::postPut();
return len;
return len;
}
void BasePVLongArray::shareData(
@@ -117,21 +121,63 @@ namespace epics { namespace pvData {
}
void BasePVLongArray::serialize(ByteBuffer *pbuffer,
SerializableControl *pflusher)
{
throw std::logic_error(notImplemented);
SerializableControl *pflusher) {
serialize(pbuffer, pflusher, 0, getLength());
}
void BasePVLongArray::deserialize(ByteBuffer *pbuffer,
DeserializableControl *pflusher)
{
throw std::logic_error(notImplemented);
DeserializableControl *pcontrol) {
int size = SerializeHelper::readSize(pbuffer, pcontrol);
if(size>=0) {
// prepare array, if necessary
if(size>getCapacity()) setCapacity(size);
// retrieve value from the buffer
int i = 0;
while(true) {
int maxIndex = min(size-i, (int)(pbuffer->getRemaining()
/sizeof(epicsInt64)))+i;
for(; i<maxIndex; i++)
value[i] = pbuffer->getLong();
if(i<size)
pcontrol->ensureData(sizeof(epicsInt64)); // TODO: is there a better way to ensureData?
else
break;
}
// set new length
setLength(size);
postPut();
}
// TODO null arrays (size == -1) not supported
}
void BasePVLongArray::serialize(ByteBuffer *pbuffer,
SerializableControl *pflusher, int offset, int count)
{
throw std::logic_error(notImplemented);
SerializableControl *pflusher, int offset, int count) {
// cache
int length = getLength();
// check bounds
if(offset<0)
offset = 0;
else if(offset>length) offset = length;
if(count<0) count = length;
int maxCount = length-offset;
if(count>maxCount) count = maxCount;
// write
SerializeHelper::writeSize(count, pbuffer, pflusher);
int end = offset+count;
int i = offset;
while(true) {
int maxIndex = min(end-i, (int)(pbuffer->getRemaining()
/sizeof(epicsInt64)))+i;
for(; i<maxIndex; i++)
pbuffer->putLong(value[i]);
if(i<end)
pflusher->flushSerializeBuffer();
else
break;
}
}
void BasePVLongArray::toString(StringBuilder buf)
@@ -146,14 +192,14 @@ namespace epics { namespace pvData {
PVField::toString(buf,indentLevel);
}
bool BasePVLongArray::operator==(PVField *pv)
bool BasePVLongArray::operator==(PVField& pv)
{
return getConvert()->equals(this,pv);
return getConvert()->equals(this, &pv);
}
bool BasePVLongArray::operator!=(PVField *pv)
bool BasePVLongArray::operator!=(PVField& pv)
{
return !(getConvert()->equals(this,pv));
return !(getConvert()->equals(this, &pv));
}
}}
#endif /* BASEPVLONGARRAY_H */

29
pvDataApp/factory/BasePVShort.h
View File

@@ -9,6 +9,7 @@
#include "convert.h"
#include "factory.h"
#include "AbstractPVField.h"
#include "byteBuffer.h"
namespace epics { namespace pvData {
@@ -26,14 +27,14 @@ namespace epics { namespace pvData {
DeserializableControl *pflusher);
virtual void toString(StringBuilder buf);
virtual void toString(StringBuilder buf,int indentLevel);
virtual bool operator==(PVField *pv) ;
virtual bool operator!=(PVField *pv) ;
virtual bool operator==(PVField& pv) ;
virtual bool operator!=(PVField& pv) ;
private:
epicsInt16 value;
};
BasePVShort::BasePVShort(PVStructure *parent,ScalarConstPtr scalar)
: PVShort(parent,scalar),value(0.0)
: PVShort(parent,scalar),value(0)
{}
BasePVShort::~BasePVShort() {}
@@ -43,33 +44,33 @@ namespace epics { namespace pvData {
void BasePVShort::put(epicsInt16 val){value = val;}
void BasePVShort::serialize(ByteBuffer *pbuffer,
SerializableControl *pflusher)
{
throw std::logic_error(notImplemented);
SerializableControl *pflusher) {
pflusher->ensureBuffer(sizeof(epicsInt16));
pbuffer->putShort(value);
}
void BasePVShort::deserialize(ByteBuffer *pbuffer,
DeserializableControl *pflusher)
{
throw std::logic_error(notImplemented);
DeserializableControl *pflusher) {
pflusher->ensureData(sizeof(epicsInt16));
value = pbuffer->getShort();
}
void BasePVShort::toString(StringBuilder buf) {toString(buf,0);}
void BasePVShort::toString(StringBuilder buf,int indentLevel)
void BasePVShort::toString(StringBuilder buf,int indentLevel)
{
getConvert()->getString(buf,this,indentLevel);
PVField::toString(buf,indentLevel);
}
bool BasePVShort::operator==(PVField *pvField)
bool BasePVShort::operator==(PVField& pvField)
{
return getConvert()->equals(this,pvField);
return getConvert()->equals(this, &pvField);
}
bool BasePVShort::operator!=(PVField *pvField)
bool BasePVShort::operator!=(PVField& pvField)
{
return !(getConvert()->equals(this,pvField));
return !(getConvert()->equals(this, &pvField));
}
}}

84
pvDataApp/factory/BasePVShortArray.h
View File

@@ -5,10 +5,14 @@
#include <cstdlib>
#include <string>
#include <cstdio>
#include <algorithm>
#include <epicsTypes.h>
#include "pvData.h"
#include "factory.h"
#include "AbstractPVScalarArray.h"
#include "serializeHelper.h"
using std::min;
namespace epics { namespace pvData {
@@ -33,8 +37,8 @@ namespace epics { namespace pvData {
SerializableControl *pflusher, int offset, int count) ;
virtual void toString(StringBuilder buf);
virtual void toString(StringBuilder buf,int indentLevel);
virtual bool operator==(PVField *pv) ;
virtual bool operator!=(PVField *pv) ;
virtual bool operator==(PVField& pv) ;
virtual bool operator!=(PVField& pv) ;
private:
epicsInt16 *value;
};
@@ -42,7 +46,7 @@ namespace epics { namespace pvData {
BasePVShortArray::BasePVShortArray(PVStructure *parent,
ScalarArrayConstPtr scalarArray)
: PVShortArray(parent,scalarArray),value(new epicsInt16[0])
{ }
{ }
BasePVShortArray::~BasePVShortArray()
{
@@ -59,14 +63,14 @@ namespace epics { namespace pvData {
}
int length = PVArray::getLength();
if(length>capacity) length = capacity;
epicsInt16 *newValue = new epicsInt16[capacity];
epicsInt16 *newValue = new epicsInt16[capacity];
for(int i=0; i<length; i++) newValue[i] = value[i];
delete[]value;
value = newValue;
PVArray::setCapacityLength(capacity,length);
}
int BasePVShortArray::get(int offset, int len, ShortArrayData *data)
int BasePVShortArray::get(int offset, int len, ShortArrayData *data)
{
int n = len;
int length = PVArray::getLength();
@@ -105,7 +109,7 @@ namespace epics { namespace pvData {
}
PVArray::setLength(length);
PVField::postPut();
return len;
return len;
}
void BasePVShortArray::shareData(
@@ -117,21 +121,63 @@ namespace epics { namespace pvData {
}
void BasePVShortArray::serialize(ByteBuffer *pbuffer,
SerializableControl *pflusher)
{
throw std::logic_error(notImplemented);
SerializableControl *pflusher) {
serialize(pbuffer, pflusher, 0, getLength());
}
void BasePVShortArray::deserialize(ByteBuffer *pbuffer,
DeserializableControl *pflusher)
{
throw std::logic_error(notImplemented);
DeserializableControl *pcontrol) {
int size = SerializeHelper::readSize(pbuffer, pcontrol);
if(size>=0) {
// prepare array, if necessary
if(size>getCapacity()) setCapacity(size);
// retrieve value from the buffer
int i = 0;
while(true) {
int maxIndex = min(size-i, (int)(pbuffer->getRemaining()
/sizeof(epicsInt16)))+i;
for(; i<maxIndex; i++)
value[i] = pbuffer->getShort();
if(i<size)
pcontrol->ensureData(sizeof(epicsInt16)); // TODO: is there a better way to ensureData?
else
break;
}
// set new length
setLength(size);
postPut();
}
// TODO null arrays (size == -1) not supported
}
void BasePVShortArray::serialize(ByteBuffer *pbuffer,
SerializableControl *pflusher, int offset, int count)
{
throw std::logic_error(notImplemented);
SerializableControl *pflusher, int offset, int count) {
// cache
int length = getLength();
// check bounds
if(offset<0)
offset = 0;
else if(offset>length) offset = length;
if(count<0) count = length;
int maxCount = length-offset;
if(count>maxCount) count = maxCount;
// write
SerializeHelper::writeSize(count, pbuffer, pflusher);
int end = offset+count;
int i = offset;
while(true) {
int maxIndex = min(end-i, (int)(pbuffer->getRemaining()
/sizeof(epicsInt16)))+i;
for(; i<maxIndex; i++)
pbuffer->putShort(value[i]);
if(i<end)
pflusher->flushSerializeBuffer();
else
break;
}
}
void BasePVShortArray::toString(StringBuilder buf)
@@ -146,14 +192,14 @@ namespace epics { namespace pvData {
PVField::toString(buf,indentLevel);
}
bool BasePVShortArray::operator==(PVField *pv)
bool BasePVShortArray::operator==(PVField& pv)
{
return getConvert()->equals(this,pv);
return getConvert()->equals(this, &pv);
}
bool BasePVShortArray::operator!=(PVField *pv)
bool BasePVShortArray::operator!=(PVField& pv)
{
return !(getConvert()->equals(this,pv));
return !(getConvert()->equals(this, &pv));
}
}}
#endif /* BASEPVSHORTARRAY_H */

26
pvDataApp/factory/BasePVString.h
View File

@@ -9,6 +9,8 @@
#include "convert.h"
#include "factory.h"
#include "AbstractPVField.h"
#include "byteBuffer.h"
#include "serializeHelper.h"
namespace epics { namespace pvData {
@@ -26,8 +28,8 @@ namespace epics { namespace pvData {
DeserializableControl *pflusher);
virtual void toString(StringBuilder buf);
virtual void toString(StringBuilder buf,int indentLevel);
virtual bool operator==(PVField *pv) ;
virtual bool operator!=(PVField *pv) ;
virtual bool operator==(PVField& pv) ;
virtual bool operator!=(PVField& pv) ;
private:
String value;
};
@@ -43,33 +45,31 @@ namespace epics { namespace pvData {
void BasePVString::put(String val){value = val;}
void BasePVString::serialize(ByteBuffer *pbuffer,
SerializableControl *pflusher)
{
throw std::logic_error(notImplemented);
SerializableControl *pflusher) {
SerializeHelper::serializeString(value, pbuffer, pflusher);
}
void BasePVString::deserialize(ByteBuffer *pbuffer,
DeserializableControl *pflusher)
{
throw std::logic_error(notImplemented);
DeserializableControl *pflusher) {
value = SerializeHelper::deserializeString(pbuffer, pflusher);
}
void BasePVString::toString(StringBuilder buf) {toString(buf,0);}
void BasePVString::toString(StringBuilder buf,int indentLevel)
void BasePVString::toString(StringBuilder buf,int indentLevel)
{
getConvert()->getString(buf,this,indentLevel);
PVField::toString(buf,indentLevel);
}
bool BasePVString::operator==(PVField *pvField)
bool BasePVString::operator==(PVField& pvField)
{
return getConvert()->equals(this,pvField);
return getConvert()->equals(this, &pvField);
}
bool BasePVString::operator!=(PVField *pvField)
bool BasePVString::operator!=(PVField& pvField)
{
return !(getConvert()->equals(this,pvField));
return !(getConvert()->equals(this, &pvField));
}
}}

63
pvDataApp/factory/BasePVStringArray.h
View File

@@ -9,6 +9,7 @@
#include "pvData.h"
#include "factory.h"
#include "AbstractPVScalarArray.h"
#include "serializeHelper.h"
namespace epics { namespace pvData {
@@ -33,8 +34,8 @@ namespace epics { namespace pvData {
SerializableControl *pflusher, int offset, int count) ;
virtual void toString(StringBuilder buf);
virtual void toString(StringBuilder buf,int indentLevel);
virtual bool operator==(PVField *pv) ;
virtual bool operator!=(PVField *pv) ;
virtual bool operator==(PVField& pv) ;
virtual bool operator!=(PVField& pv) ;
private:
String *value;
};
@@ -42,7 +43,7 @@ namespace epics { namespace pvData {
BasePVStringArray::BasePVStringArray(PVStructure *parent,
ScalarArrayConstPtr scalarArray)
: PVStringArray(parent,scalarArray),value(new String[0])
{ }
{ }
BasePVStringArray::~BasePVStringArray()
{
@@ -59,14 +60,14 @@ namespace epics { namespace pvData {
}
int length = PVArray::getLength();
if(length>capacity) length = capacity;
String *newValue = new String[capacity];
String *newValue = new String[capacity];
for(int i=0; i<length; i++) newValue[i] = value[i];
delete[]value;
value = newValue;
PVArray::setCapacityLength(capacity,length);
}
int BasePVStringArray::get(int offset, int len, StringArrayData *data)
int BasePVStringArray::get(int offset, int len, StringArrayData *data)
{
int n = len;
int length = PVArray::getLength();
@@ -105,7 +106,7 @@ namespace epics { namespace pvData {
}
PVArray::setLength(length);
PVField::postPut();
return len;
return len;
}
void BasePVStringArray::shareData(
@@ -117,21 +118,45 @@ namespace epics { namespace pvData {
}
void BasePVStringArray::serialize(ByteBuffer *pbuffer,
SerializableControl *pflusher)
{
throw std::logic_error(notImplemented);
SerializableControl *pflusher) {
serialize(pbuffer, pflusher, 0, getLength());
}
void BasePVStringArray::deserialize(ByteBuffer *pbuffer,
DeserializableControl *pflusher)
{
throw std::logic_error(notImplemented);
DeserializableControl *pcontrol) {
int size = SerializeHelper::readSize(pbuffer, pcontrol);
if(size>=0) {
// prepare array, if necessary
if(size>getCapacity()) setCapacity(size);
// retrieve value from the buffer
for(int i = 0; i<size; i++)
value[i] = SerializeHelper::deserializeString(pbuffer,
pcontrol);
// set new length
setLength(size);
postPut();
}
// TODO null arrays (size == -1) not supported
}
void BasePVStringArray::serialize(ByteBuffer *pbuffer,
SerializableControl *pflusher, int offset, int count)
{
throw std::logic_error(notImplemented);
SerializableControl *pflusher, int offset, int count) {
int length = getLength();
// check bounds
if(offset<0)
offset = 0;
else if(offset>length) offset = length;
if(count<0) count = length;
int maxCount = length-offset;
if(count>maxCount) count = maxCount;
// write
SerializeHelper::writeSize(count, pbuffer, pflusher);
int end = offset+count;
for(int i = offset; i<end; i++)
SerializeHelper::serializeString(value[i], pbuffer, pflusher);
}
void BasePVStringArray::toString(StringBuilder buf)
@@ -146,14 +171,14 @@ namespace epics { namespace pvData {
PVField::toString(buf,indentLevel);
}
bool BasePVStringArray::operator==(PVField *pv)
bool BasePVStringArray::operator==(PVField& pv)
{
return getConvert()->equals(this,pv);
return getConvert()->equals(this, &pv);
}
bool BasePVStringArray::operator!=(PVField *pv)
bool BasePVStringArray::operator!=(PVField& pv)
{
return !(getConvert()->equals(this,pv));
return !(getConvert()->equals(this, &pv));
}
}}
#endif /* BASEPVSTRINGARRAY_H */

122
pvDataApp/factory/BasePVStructure.h
View File

@@ -30,7 +30,7 @@ namespace epics { namespace pvData {
for(int i=0; i<numberFields; i++) {
delete pvFields[i];
}
delete[] pvFields;
if (pvFields) delete[] pvFields;
}
static PVField *findSubField(String fieldName,PVStructure *pvStructure);
@@ -452,59 +452,115 @@ namespace epics { namespace pvData {
toStringPvt(buf,0);
}
void PVStructure::toString(StringBuilder buf,int indentLevel)
void PVStructure::toString(StringBuilder buf,int indentLevel)
{
*buf += "structure ";
toStringPvt(buf,indentLevel);
}
void PVStructure::serialize(
ByteBuffer *pbuffer,SerializableControl *pflusher)
{
throw std::logic_error(notImplemented);
}
void PVStructure::deserialize(
ByteBuffer *pbuffer,DeserializableControl *pflusher)
{
throw std::logic_error(notImplemented);
}
void PVStructure::serialize(ByteBuffer *pbuffer,
SerializableControl *pflusher, int offset, int count)
{
throw std::logic_error(notImplemented);
}
void PVStructure::serialize(ByteBuffer *pbuffer,
SerializableControl *pflusher,BitSet *pbitSet)
{
throw std::logic_error(notImplemented);
SerializableControl *pflusher) {
for(int i = 0; i<pImpl->numberFields; i++)
pImpl->pvFields[i]->serialize(pbuffer, pflusher);
}
void PVStructure::deserialize(ByteBuffer *pbuffer,
DeserializableControl*pflusher,BitSet *pbitSet)
{
DeserializableControl *pcontrol) {
for(int i = 0; i<pImpl->numberFields; i++)
pImpl->pvFields[i]->deserialize(pbuffer, pcontrol);
}
void PVStructure::serialize(ByteBuffer *pbuffer,
SerializableControl *pflusher, int offset, int count) {
throw std::logic_error(notImplemented);
}
bool PVStructure::operator==(PVField *obj)
void PVStructure::serialize(ByteBuffer *pbuffer,
SerializableControl *pflusher, BitSet *pbitSet) {
int offset = getFieldOffset();
int numberFields = getNumberFields();
int next = pbitSet->nextSetBit(offset);
// no more changes or no changes in this structure
if(next<0||next>=offset+numberFields) return;
// entire structure
if(offset==next) {
serialize(pbuffer, pflusher);
return;
}
for(int i = 0; i<pImpl->numberFields; i++) {
PVField* pvField = pImpl->pvFields[i];
offset = pvField->getFieldOffset();
numberFields = pvField->getNumberFields();
next = pbitSet->nextSetBit(offset);
// no more changes
if(next<0) return;
// no change in this pvField
if(next>=offset+numberFields) continue;
// serialize field or fields
if(numberFields==1)
pvField->serialize(pbuffer, pflusher);
else
((PVStructure*)pvField)->serialize(pbuffer, pflusher,
pbitSet);
}
}
void PVStructure::deserialize(ByteBuffer *pbuffer,
DeserializableControl *pcontrol, BitSet *pbitSet) {
int offset = getFieldOffset();
int numberFields = getNumberFields();
int next = pbitSet->nextSetBit(offset);
// no more changes or no changes in this structure
if(next<0||next>=offset+numberFields) return;
// entire structure
if(offset==next) {
deserialize(pbuffer, pcontrol);
return;
}
for(int i = 0; i<pImpl->numberFields; i++) {
PVField* pvField = pImpl->pvFields[i];
offset = pvField->getFieldOffset();
numberFields = pvField->getNumberFields();
next = pbitSet->nextSetBit(offset);
// no more changes
if(next<0) return;
// no change in this pvField
if(next>=offset+numberFields) continue;
// deserialize field or fields
if(numberFields==1)
pvField->deserialize(pbuffer, pcontrol);
else
((PVStructure*)pvField)->deserialize(pbuffer, pcontrol,
pbitSet);
}
}
bool PVStructure::operator==(PVField &obj)
{
PVStructure *b = dynamic_cast<PVStructure *>(obj);
if(b==0) return false;
PVFieldPtrArray bFields = b->getPVFields();
PVStructure &b = dynamic_cast<PVStructure &>(obj);
PVFieldPtrArray bFields = b.pImpl->pvFields;
PVFieldPtrArray pvFields = pImpl->pvFields;
int len = b->getNumberFields();
int len = b.pImpl->numberFields;
if(len!=pImpl->numberFields) return false;
for (int i = 0; i < len; i++) {
if (!(pvFields[i]==bFields[i])) return false;
if (!(*pvFields[i]==*bFields[i])) return false;
}
return true;
}
bool PVStructure::operator!=(PVField *pv)
bool PVStructure::operator!=(PVField &pv)
{
return !(this==pv);
return !(*this==pv);
}
static PVField *findSubField(String fieldName,PVStructure *pvStructure) {

88
pvDataApp/factory/BasePVStructureArray.h
View File

@@ -7,6 +7,7 @@
#include <cstdio>
#include "pvData.h"
#include "factory.h"
#include "serializeHelper.h"
namespace epics { namespace pvData {
@@ -30,8 +31,8 @@ namespace epics { namespace pvData {
PVStructurePtrArray from, int fromOffset);
virtual void toString(StringBuilder buf) ;
virtual void toString(StringBuilder buf,int indentLevel) ;
virtual bool operator==(PVField *pv);
virtual bool operator!=(PVField *pv);
virtual bool operator==(PVField &pv);
virtual bool operator!=(PVField &pv);
virtual void shareData( PVStructurePtrArray value,int capacity,int length);
virtual void serialize(ByteBuffer *pbuffer,
SerializableControl *pflusher);
@@ -72,21 +73,21 @@ namespace epics { namespace pvData {
int limit = length;
if(length>capacity) limit = capacity;
for(int i=0; i<limit; i++) newValue[i] = value[i];
for(int i=limit; i<capacity; i++) newValue[i] = 0;
for(int i=limit; i<capacity; i++) newValue[i] = 0;
if(length>capacity) length = capacity;
delete[] value;
value = newValue;
setCapacityLength(capacity,length);
}
StructureArrayConstPtr BasePVStructureArray::getStructureArray()
StructureArrayConstPtr BasePVStructureArray::getStructureArray()
{
return structureArray;
}
int BasePVStructureArray::get(
int offset, int len, StructureArrayData *data)
int offset, int len, StructureArrayData *data)
{
int n = len;
int length = getLength();
@@ -135,7 +136,7 @@ namespace epics { namespace pvData {
value[i+offset] = frompv;
}
postPut();
return len;
return len;
}
void BasePVStructureArray::shareData(
@@ -148,38 +149,79 @@ namespace epics { namespace pvData {
void BasePVStructureArray::toString(StringBuilder buf) {toString(buf,0);}
void BasePVStructureArray::toString(StringBuilder buf,int indentLevel)
void BasePVStructureArray::toString(StringBuilder buf,int indentLevel)
{
getConvert()->getString(buf,this,indentLevel);
PVField::toString(buf,indentLevel);
}
void BasePVStructureArray::serialize(
ByteBuffer *pbuffer,SerializableControl *pflusher)
{
throw std::logic_error(notImplemented);
void BasePVStructureArray::serialize(ByteBuffer *pbuffer,
SerializableControl *pflusher) {
serialize(pbuffer, pflusher, 0, getLength());
}
void BasePVStructureArray::deserialize(
ByteBuffer *pbuffer,DeserializableControl *pflusher)
{
throw std::logic_error(notImplemented);
void BasePVStructureArray::deserialize(ByteBuffer *pbuffer,
DeserializableControl *pcontrol) {
int size = SerializeHelper::readSize(pbuffer, pcontrol);
if(size>=0) {
// prepare array, if necessary
if(size>getCapacity()) setCapacity(size);
for(int i = 0; i<size; i++) {
pcontrol->ensureData(1);
epicsInt8 temp = pbuffer->getByte();
if(temp==0) {
value[i] = NULL;
}
else {
if(value[i]==NULL) {
value[i] = getPVDataCreate()->createPVStructure(
NULL, structureArray->getStructure());
}
value[i]->deserialize(pbuffer, pcontrol);
}
}
setLength(size);
postPut();
}
}
void BasePVStructureArray::serialize(ByteBuffer *pbuffer,
SerializableControl *pflusher, int offset, int count)
{
throw std::logic_error(notImplemented);
SerializableControl *pflusher, int offset, int count) {
// cache
int length = getLength();
// check bounds
if(offset<0)
offset = 0;
else if(offset>length) offset = length;
if(count<0) count = length;
int maxCount = length-offset;
if(count>maxCount) count = maxCount;
// write
SerializeHelper::writeSize(count, pbuffer, pflusher);
for(int i = 0; i<count; i++) {
if(pbuffer->getRemaining()<1) pflusher->flushSerializeBuffer();
PVStructure* pvStructure = value[i+offset];
if(pvStructure==NULL) {
pbuffer->putByte(0);
}
else {
pbuffer->putByte(1);
pvStructure->serialize(pbuffer, pflusher);
}
}
}
bool BasePVStructureArray::operator==(PVField *pvField)
bool BasePVStructureArray::operator==(PVField &pvField)
{
return getConvert()->equals(this,pvField);
return getConvert()->equals(this,&pvField);
}
bool BasePVStructureArray::operator!=(PVField *pvField)
bool BasePVStructureArray::operator!=(PVField &pvField)
{
return !(getConvert()->equals(this,pvField));
return !(getConvert()->equals(this,&pvField));
}
}}

1
pvDataApp/factory/Makefile
View File

@@ -37,6 +37,7 @@ LIBSRCS += StandardPVField.cpp
LIBRARY=pvFactory
pvFactory_LIBS += Com
pvFactory_LIBS += pvMisc
include $(TOP)/configure/RULES
#----------------------------------------

18
pvDataApp/misc/byteBuffer.cpp
View File

@@ -101,17 +101,17 @@ namespace epics {
return val;
}
ByteBuffer* ByteBuffer::put(const char* src, int offset, int count) {
if(count>getRemaining()) throw EpicsException("buffer overflow");
strncpy(&_buffer[_position], &src[offset], count);
_position += count;
return this;
void ByteBuffer::get(char* dst, int offset, int count) {
if(count>getRemaining()) throw EpicsException("buffer underflow");
for(int i = 0; i<count; i++)
dst[offset+i] = _buffer[_position++];
}
void ByteBuffer::get(char*dst, int offset, int count) {
if(count>getRemaining()) throw EpicsException("buffer underflow");
strncpy(&dst[offset], &_buffer[_position], count);
_position += count;
ByteBuffer* ByteBuffer::put(const char* src, int offset, int count) {
if(count>getRemaining()) throw EpicsException("buffer overflow");
for(int i = 0; i<count; i++)
_buffer[_position++] = src[offset+i];
return this;
}
ByteBuffer* ByteBuffer::putBoolean(bool value) {

8
pvDataApp/pv/pvData.h
View File

@@ -82,8 +82,8 @@ namespace epics { namespace pvData {
void setPostHandler(PostHandler *postHandler);
virtual void toString(StringBuilder buf) ;
virtual void toString(StringBuilder buf,int indentLevel) ;
virtual bool operator==(PVField *pv) = 0;
virtual bool operator!=(PVField *pv) = 0;
virtual bool operator==(PVField &pv) = 0;
virtual bool operator!=(PVField &pv) = 0;
protected:
PVField(PVStructure *parent,FieldConstPtr field);
void replaceStructure(PVStructure *pvStructure);
@@ -206,8 +206,8 @@ namespace epics { namespace pvData {
String extendsStructureName);
virtual void toString(StringBuilder buf) ;
virtual void toString(StringBuilder buf,int indentLevel) ;
virtual bool operator==(PVField *pv) ;
virtual bool operator!=(PVField *pv) ;
virtual bool operator==(PVField &pv) ;
virtual bool operator!=(PVField &pv) ;
virtual void serialize(
ByteBuffer *pbuffer,SerializableControl *pflusher) ;
virtual void deserialize(

4
pvDataApp/test/Makefile
View File

@@ -31,6 +31,10 @@ PROD_HOST += testBaseException
testBaseException_SRCS += testBaseException.cpp
testBaseException_LIBS += pvMisc
PROD_HOST += testSerialization
testSerialization_SRCS += testSerialization.cpp
testSerialization_LIBS += pvMisc pvFactory Com
include $(TOP)/configure/RULES
#----------------------------------------
# ADD RULES AFTER THIS LINE

634
pvDataApp/test/testSerialization.cpp Normal file
View File

@@ -0,0 +1,634 @@
/*
* testSerialization.cpp
*
* Created on: Oct 25, 2010
* Author: Miha Vitorovic
*/
#include <iostream>
#include <epicsAssert.h>
#include "pvIntrospect.h"
#include "pvData.h"
#include "serialize.h"
#include "noDefaultMethods.h"
#include "byteBuffer.h"
#define BYTE_MAX_VALUE 127
#define BYTE_MIN_VALUE -128
#define SHORT_MAX_VALUE 32767
#define SHORT_MIN_VALUE -32768
#define INT_MAX_VALUE 2147483647
#define INT_MIN_VALUE -2147483648
#define LONG_MAX_VALUE 9223372036854775807LL
#define LONG_MIN_VALUE -9223372036854775808LL
#define FLOAT_MAX_VALUE 3.4028235E38
#define FLOAT_MIN_VALUE 1.4E-45
#define DOUBLE_MAX_VALUE 1.7976931348623157E308
#define DOUBLE_MIN_VALUE 4.9E-324
using namespace epics::pvData;
using std::cout;
namespace epics {
namespace pvData {
class SerializableControlImpl : public SerializableControl,
public NoDefaultMethods {
public:
virtual void flushSerializeBuffer() {
}
virtual void ensureBuffer(int size) {
}
SerializableControlImpl() {
}
virtual ~SerializableControlImpl() {
}
};
class DeserializableControlImpl : public DeserializableControl,
public NoDefaultMethods {
public:
virtual void ensureData(int size) {
}
DeserializableControlImpl() {
}
virtual ~DeserializableControlImpl() {
}
};
}
}
static SerializableControl* flusher;
static DeserializableControl* control;
static ByteBuffer* buffer;
void serializationTest(PVField* field) {
buffer->clear();
// serialize
field->serialize(buffer, flusher);
buffer->flip();
// create new instance and deserialize
PVField* deserializedField = getPVDataCreate()->createPVField(NULL,
field->getField());
deserializedField->deserialize(buffer, control);
// must equal
assert((*field)==(*deserializedField));
delete deserializedField; // clean up
}
void testScalar() {
cout<<"Testing scalars...\n";
PVDataCreate* factory = getPVDataCreate();
assert(factory!=NULL);
cout<<"\tPVBoolean\n";
PVBoolean* pvBoolean = (PVBoolean*)factory->createPVScalar(NULL,
"pvBoolean", epics::pvData::pvBoolean);
pvBoolean->put(false);
serializationTest(pvBoolean);
pvBoolean->put(true);
serializationTest(pvBoolean);
delete pvBoolean;
cout<<"\tPVByte\n";
PVByte* pvByte = (PVByte*)factory->createPVScalar(NULL, "pvByte",
epics::pvData::pvByte);
pvByte->put(0);
serializationTest(pvByte);
pvByte->put(12);
serializationTest(pvByte);
pvByte->put(BYTE_MAX_VALUE);
serializationTest(pvByte);
pvByte->put(BYTE_MIN_VALUE);
serializationTest(pvByte);
delete pvByte;
cout<<"\tPVShort\n";
PVShort* pvShort = (PVShort*)factory->createPVScalar(NULL, "pvShort",
epics::pvData::pvShort);
pvShort->put(0);
serializationTest(pvShort);
pvShort->put(123);
serializationTest(pvShort);
pvShort->put(BYTE_MAX_VALUE);
serializationTest(pvShort);
pvShort->put(BYTE_MIN_VALUE);
serializationTest(pvShort);
pvShort->put(SHORT_MAX_VALUE);
serializationTest(pvShort);
pvShort->put(SHORT_MIN_VALUE);
serializationTest(pvShort);
delete pvShort;
cout<<"\tPVInt\n";
PVInt* pvInt = (PVInt*)factory->createPVScalar(NULL, "pvInt",
epics::pvData::pvInt);
pvInt->put(0);
serializationTest(pvInt);
pvInt->put(123456);
serializationTest(pvInt);
pvInt->put(BYTE_MAX_VALUE);
serializationTest(pvInt);
pvInt->put(BYTE_MIN_VALUE);
serializationTest(pvInt);
pvInt->put(SHORT_MAX_VALUE);
serializationTest(pvInt);
pvInt->put(SHORT_MIN_VALUE);
serializationTest(pvInt);
pvInt->put(INT_MAX_VALUE);
serializationTest(pvInt);
pvInt->put(INT_MIN_VALUE);
serializationTest(pvInt);
delete pvInt;
cout<<"\tPVLong\n";
PVLong* pvLong = (PVLong*)factory->createPVScalar(NULL, "pvLong",
epics::pvData::pvLong);
pvLong->put(0);
serializationTest(pvLong);
pvLong->put(12345678901LL);
serializationTest(pvLong);
pvLong->put(BYTE_MAX_VALUE);
serializationTest(pvLong);
pvLong->put(BYTE_MIN_VALUE);
serializationTest(pvLong);
pvLong->put(SHORT_MAX_VALUE);
serializationTest(pvLong);
pvLong->put(SHORT_MIN_VALUE);
serializationTest(pvLong);
pvLong->put(INT_MAX_VALUE);
serializationTest(pvLong);
pvLong->put(INT_MIN_VALUE);
serializationTest(pvLong);
pvLong->put(LONG_MAX_VALUE);
serializationTest(pvLong);
pvLong->put(LONG_MIN_VALUE);
serializationTest(pvLong);
delete pvLong;
cout<<"\tPVFloat\n";
PVFloat* pvFloat = (PVFloat*)factory->createPVScalar(NULL, "pvFloat",
epics::pvData::pvFloat);
pvFloat->put(0);
serializationTest(pvFloat);
pvFloat->put(12.345);
serializationTest(pvFloat);
pvFloat->put(FLOAT_MAX_VALUE);
serializationTest(pvFloat);
pvFloat->put(FLOAT_MIN_VALUE);
serializationTest(pvFloat);
delete pvFloat;
cout<<"\tPVDouble\n";
PVDouble* pvDouble = (PVDouble*)factory->createPVScalar(NULL, "pvDouble",
epics::pvData::pvDouble);
pvDouble->put(0);
serializationTest(pvDouble);
pvDouble->put(12.345);
serializationTest(pvDouble);
pvDouble->put(DOUBLE_MAX_VALUE);
serializationTest(pvDouble);
pvDouble->put(DOUBLE_MIN_VALUE);
serializationTest(pvDouble);
delete pvDouble;
cout<<"\tPVString\n";
PVString* pvString = (PVString*)factory->createPVScalar(NULL, "pvString",
epics::pvData::pvString);
pvString->put("");
serializationTest(pvString);
pvString->put("s");
serializationTest(pvString);
pvString->put("string");
serializationTest(pvString);
pvString->put("string with spaces");
serializationTest(pvString);
pvString->put("string with spaces and special characters\f\n");
serializationTest(pvString);
// huge string test
pvString->put(String(10000, 'a'));
serializationTest(pvString);
delete pvString;
cout<<"!!! PASSED\n\n";
}
void testArray() {
cout<<"Testing arrays...\n";
PVDataCreate* factory = getPVDataCreate();
assert(factory!=NULL);
cout<<"\tPVBooleanArray\n";
bool boolEmpty[] = { };
bool bv[] = { false, true, false, true, true };
PVBooleanArray* pvBoolean = (PVBooleanArray*)factory->createPVScalarArray(
NULL, "pvBooleanArray", epics::pvData::pvBoolean);
pvBoolean->put(0, 0, boolEmpty, 0);
serializationTest(pvBoolean);
pvBoolean->put(0, 5, bv, 0);
serializationTest(pvBoolean);
delete pvBoolean;
cout<<"\tPVByteArray\n";
epicsInt8 byteEmpty[] = { };
epicsInt8 byv[] = { 0, 1, 2, -1, BYTE_MAX_VALUE, BYTE_MAX_VALUE-1,
BYTE_MIN_VALUE+1, BYTE_MIN_VALUE };
PVByteArray* pvByte = (PVByteArray*)factory->createPVScalarArray(NULL,
"pvByteArray", epics::pvData::pvByte);
pvByte->put(0, 0, byteEmpty, 0);
serializationTest(pvByte);
pvByte->put(0, 8, byv, 0);
serializationTest(pvByte);
delete pvByte;
cout<<"\tPVShortArray\n";
epicsInt16 shortEmpty[] = { };
epicsInt16 sv[] = { 0, 1, 2, -1, SHORT_MAX_VALUE, SHORT_MAX_VALUE-1,
SHORT_MIN_VALUE+1, SHORT_MIN_VALUE };
PVShortArray* pvShort = (PVShortArray*)factory->createPVScalarArray(NULL,
"pvShortArray", epics::pvData::pvShort);
pvShort->put(0, 0, shortEmpty, 0);
serializationTest(pvShort);
pvShort->put(0, 8, sv, 0);
serializationTest(pvShort);
delete pvShort;
cout<<"\tPVIntArray\n";
epicsInt32 intEmpty[] = { };
epicsInt32 iv[] = { 0, 1, 2, -1, INT_MAX_VALUE, INT_MAX_VALUE-1,
INT_MIN_VALUE+1, INT_MIN_VALUE };
PVIntArray* pvInt = (PVIntArray*)factory->createPVScalarArray(NULL,
"pvIntArray", epics::pvData::pvInt);
pvInt->put(0, 0, intEmpty, 0);
serializationTest(pvInt);
pvInt->put(0, 8, iv, 0);
serializationTest(pvInt);
delete pvInt;
cout<<"\tPVLongArray\n";
epicsInt64 longEmpty[] = { };
epicsInt64 lv[] = { 0, 1, 2, -1, LONG_MAX_VALUE, LONG_MAX_VALUE-1,
LONG_MIN_VALUE+1, LONG_MIN_VALUE };
PVLongArray* pvLong = (PVLongArray*)factory->createPVScalarArray(NULL,
"pvLongArray", epics::pvData::pvLong);
pvLong->put(0, 0, longEmpty, 0);
serializationTest(pvLong);
pvLong->put(0, 8, lv, 0);
serializationTest(pvLong);
delete pvLong;
cout<<"\tPVFloatArray\n";
float floatEmpty[] = { };
float fv[] = { (float)0.0, (float)1.1, (float)2.3, (float)-1.4,
FLOAT_MAX_VALUE, FLOAT_MAX_VALUE-(float)123456.789, FLOAT_MIN_VALUE
+(float)1.1, FLOAT_MIN_VALUE };
PVFloatArray* pvFloat = (PVFloatArray*)factory->createPVScalarArray(NULL,
"pvFloatArray", epics::pvData::pvFloat);
pvFloat->put(0, 0, floatEmpty, 0);
serializationTest(pvFloat);
pvFloat->put(0, 8, fv, 0);
serializationTest(pvFloat);
delete pvFloat;
cout<<"\tPVDoubleArray\n";
double doubleEmpty[] = { };
double dv[] = { (double)0.0, (double)1.1, (double)2.3, (double)-1.4,
DOUBLE_MAX_VALUE, DOUBLE_MAX_VALUE-(double)123456.789,
DOUBLE_MIN_VALUE+(double)1.1, DOUBLE_MIN_VALUE };
PVDoubleArray* pvDouble = (PVDoubleArray*)factory->createPVScalarArray(
NULL, "pvDoubleArray", epics::pvData::pvDouble);
pvDouble->put(0, 0, doubleEmpty, 0);
serializationTest(pvDouble);
pvDouble->put(0, 8, dv, 0);
serializationTest(pvDouble);
delete pvDouble;
cout<<"\tPVStringArray\n";
String stringEmpty[] = { };
String
strv[] =
{
"",
"a",
"a b",
" ",
"test",
"smile",
"this is a little longer string... maybe a little but longer... this makes test better" };
PVStringArray* pvString = (PVStringArray*)factory->createPVScalarArray(
NULL, "pvStringArray", epics::pvData::pvString);
pvString->put(0, 0, stringEmpty, 0);
serializationTest(pvString);
pvString->put(0, 7, strv, 0);
serializationTest(pvString);
delete pvString;
cout<<"!!! PASSED\n\n";
}
void testScalarEquals() {
cout<<"Testing scalar equals...\n";
PVDataCreate* factory = getPVDataCreate();
assert(factory!=NULL);
PVScalar *scalar1, *scalar2;
scalar1 = factory->createPVScalar(NULL, "pvBoolean",
epics::pvData::pvBoolean);
scalar2 = factory->createPVScalar(NULL, "pvBoolean",
epics::pvData::pvBoolean);
assert((*scalar1)==(*scalar2));
delete scalar1;
delete scalar2;
scalar1 = factory->createPVScalar(NULL, "pvByte", epics::pvData::pvByte);
scalar2 = factory->createPVScalar(NULL, "pvByte", epics::pvData::pvByte);
assert((*scalar1)==(*scalar2));
delete scalar1;
delete scalar2;
scalar1 = factory->createPVScalar(NULL, "pvShort", epics::pvData::pvShort);
scalar2 = factory->createPVScalar(NULL, "pvShort", epics::pvData::pvShort);
assert((*scalar1)==(*scalar2));
delete scalar1;
delete scalar2;
scalar1 = factory->createPVScalar(NULL, "pvInt", epics::pvData::pvInt);
scalar2 = factory->createPVScalar(NULL, "pvInt", epics::pvData::pvInt);
assert((*scalar1)==(*scalar2));
delete scalar1;
delete scalar2;
scalar1 = factory->createPVScalar(NULL, "pvLong", epics::pvData::pvLong);
scalar2 = factory->createPVScalar(NULL, "pvLong", epics::pvData::pvLong);
assert((*scalar1)==(*scalar2));
delete scalar1;
delete scalar2;
scalar1 = factory->createPVScalar(NULL, "pvFloat", epics::pvData::pvFloat);
scalar2 = factory->createPVScalar(NULL, "pvFloat", epics::pvData::pvFloat);
assert((*scalar1)==(*scalar2));
delete scalar1;
delete scalar2;
scalar1
= factory->createPVScalar(NULL, "pvDouble", epics::pvData::pvDouble);
scalar2
= factory->createPVScalar(NULL, "pvDouble", epics::pvData::pvDouble);
assert((*scalar1)==(*scalar2));
delete scalar1;
delete scalar2;
scalar1
= factory->createPVScalar(NULL, "pvString", epics::pvData::pvString);
scalar2
= factory->createPVScalar(NULL, "pvString", epics::pvData::pvString);
assert((*scalar1)==(*scalar2));
delete scalar1;
delete scalar2;
FieldCreate* fieldCreate = getFieldCreate();
FieldConstPtr fields[2];
fields[0] = fieldCreate->createScalar("secondsSinceEpoch",
epics::pvData::pvLong);
fields[1] = fieldCreate->createScalar("nanoSeconds", epics::pvData::pvInt);
StructureConstPtr structure = fieldCreate->createStructure("timeStamp", 2,
fields);
PVStructure* pvStruct1 = factory->createPVStructure(NULL, structure);
PVStructure* pvStruct2 = factory->createPVStructure(NULL, structure);
assert((*pvStruct1)==(*pvStruct2));
delete pvStruct2;
delete pvStruct1;
// 'structure' and 'fields' are deleted implicitly
cout<<"!!! PASSED\n\n";
}
void testScalarNonInitialized() {
cout<<"Testing scalar non-initialized...\n";
PVDataCreate* factory = getPVDataCreate();
assert(factory!=NULL);
PVScalar* scalar;
scalar = factory->createPVScalar(NULL, "pvBoolean",
epics::pvData::pvBoolean);
serializationTest(scalar);
delete scalar;
scalar = factory->createPVScalar(NULL, "pvByte", epics::pvData::pvByte);
serializationTest(scalar);
delete scalar;
scalar = factory->createPVScalar(NULL, "pvShort", epics::pvData::pvShort);
serializationTest(scalar);
delete scalar;
scalar = factory->createPVScalar(NULL, "pvInt", epics::pvData::pvInt);
serializationTest(scalar);
delete scalar;
scalar = factory->createPVScalar(NULL, "pvLong", epics::pvData::pvLong);
serializationTest(scalar);
delete scalar;
scalar = factory->createPVScalar(NULL, "pvFloat", epics::pvData::pvFloat);
serializationTest(scalar);
delete scalar;
scalar = factory->createPVScalar(NULL, "pvDouble", epics::pvData::pvDouble);
serializationTest(scalar);
delete scalar;
scalar = factory->createPVScalar(NULL, "pvString", epics::pvData::pvString);
serializationTest(scalar);
delete scalar;
FieldCreate* fieldCreate = getFieldCreate();
FieldConstPtr fields[2];
fields[0] = fieldCreate->createScalar("secondsSinceEpoch",
epics::pvData::pvLong);
fields[1] = fieldCreate->createScalar("nanoSeconds", epics::pvData::pvInt);
StructureConstPtr structure = fieldCreate->createStructure("timeStamp", 2,
fields);
PVStructure* pvStruct = factory->createPVStructure(NULL, structure);
serializationTest(pvStruct);
delete pvStruct; // 'structure' and 'fields' are deleted implicitly
cout<<"!!! PASSED\n\n";
}
void testArrayNonInitialized() {
cout<<"Testing array non-initialized...\n";
PVDataCreate* factory = getPVDataCreate();
assert(factory!=NULL);
PVArray* array;
array = factory->createPVScalarArray(NULL, "pvBooleanArray",
epics::pvData::pvBoolean);
serializationTest(array);
delete array;
array = factory->createPVScalarArray(NULL, "pvByteArray",
epics::pvData::pvByte);
serializationTest(array);
delete array;
array = factory->createPVScalarArray(NULL, "pvShortArray",
epics::pvData::pvShort);
serializationTest(array);
delete array;
array = factory->createPVScalarArray(NULL, "pvIntArray",
epics::pvData::pvInt);
serializationTest(array);
delete array;
array = factory->createPVScalarArray(NULL, "pvLongArray",
epics::pvData::pvLong);
serializationTest(array);
delete array;
array = factory->createPVScalarArray(NULL, "pvFloatArray",
epics::pvData::pvFloat);
serializationTest(array);
delete array;
array = factory->createPVScalarArray(NULL, "pvDoubleArray",
epics::pvData::pvDouble);
serializationTest(array);
delete array;
array = factory->createPVScalarArray(NULL, "pvStringArray",
epics::pvData::pvString);
serializationTest(array);
delete array;
FieldCreate* fieldCreate = getFieldCreate();
FieldConstPtr fields[2];
fields[0] = fieldCreate->createScalar("secondsSinceEpoch",
epics::pvData::pvLong);
fields[1] = fieldCreate->createScalar("nanoSeconds", epics::pvData::pvInt);
StructureConstPtr structure = fieldCreate->createStructure("timeStamp", 2,
fields);
StructureArrayConstPtr structureArray = fieldCreate->createStructureArray(
"timeStampArray", structure);
PVStructureArray* pvStructArray = factory->createPVStructureArray(NULL,
structureArray);
serializationTest(pvStructArray);
delete pvStructArray; // also deletes 'structureArray',
//'structureArray' also deletes 'structure'
//'structure' also deletes 'fields'
cout<<"!!! PASSED\n\n";
}
void testStructure() {
cout<<"Testing structure...\n";
FieldCreate* fieldCreate = getFieldCreate();
PVDataCreate* pvDataCreate = getPVDataCreate();
assert(fieldCreate!=NULL);
assert(pvDataCreate!=NULL);
cout<<"\tSimple structure serialization\n";
FieldConstPtr fields[2];
fields[0] = fieldCreate->createScalar("secondsSinceEpoch",
epics::pvData::pvLong);
fields[1] = fieldCreate->createScalar("nanoSeconds", epics::pvData::pvInt);
PVStructure* pvStructure = pvDataCreate->createPVStructure(NULL,
"timestamp", 2, fields);
pvStructure->getLongField(fields[0]->getFieldName())->put(123);
pvStructure->getIntField(fields[1]->getFieldName())->put(456);
serializationTest(pvStructure);
//serializationTest(pvStructure->getStructure());
cout<<"\tComplex structure serialization\n";
// and more complex :)
FieldConstPtr fields2[4];
fields2[0] = fieldCreate->createScalar("longVal", epics::pvData::pvLong);
fields2[1] = fieldCreate->createScalar("intVal", epics::pvData::pvInt);
fields2[2] = fieldCreate->createScalarArray("values", epics::pvData::pvDouble);
fields2[3] = fieldCreate->createStructure("timeStamp", 2, fields);
PVStructure* pvStructure2 = pvDataCreate->createPVStructure(NULL,
"complexStructure", 4, fields2);
pvStructure2->getLongField(fields2[0]->getFieldName())->put(1234);
pvStructure2->getIntField(fields2[1]->getFieldName())->put(4567);
PVDoubleArray* da = (PVDoubleArray*)pvStructure2->getScalarArrayField(
fields2[2]->getFieldName(), epics::pvData::pvDouble);
double dd[] = { 1.2, 3.4, 4.5 };
da->put(0, 3, dd, 0);
PVStructure* ps = pvStructure2->getStructureField(
fields2[3]->getFieldName());
ps->getLongField(fields[0]->getFieldName())->put(789);
ps->getIntField(fields[1]->getFieldName())->put(1011);
serializationTest(pvStructure2);
//serializationTest(pvStructure2->getStructure());
delete pvStructure2;
delete pvStructure;
cout<<"!!! PASSED\n\n";
}
/*
void testIntrospectionSerialization() {
cout<<"Testing introspection serialization...\n";
FieldCreate* factory = getFieldCreate();
assert(factory!=NULL);
ScalarConstPtr scalar = factory->createScalar("scalar", epics::pvData::pvDouble);
serializatioTest(scalar);
delete scalar;
ScalarArrayConstPtr array = factory->createScalarArray("array", epics::pvData::pvDouble);
serializatioTest(array);
delete array;
cout<<"!!! PASSED\n\n";
}
*/
int main(int argc, char *argv[]) {
flusher = new SerializableControlImpl();
control = new DeserializableControlImpl();
buffer = new ByteBuffer(1<<16);
testScalarEquals();
testScalar();
testArray();
testScalarNonInitialized();
testArrayNonInitialized();
testStructure();
//testIntrospectionSerialization();
delete buffer;
delete control;
delete flusher;
cout<<"\nDone!\n";
return (0);
}