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

serialization test, shared-ptr const

Browse Source
This commit is contained in:
Matej Sekoranja
2012-05-18 11:42:57 +02:00
parent 24a08fe348
commit 8040ad5fc7
16 changed files with 354 additions and 506 deletions
Download Patch File Download Diff File Expand all files Collapse all files

7
pvDataApp/factory/Compare.cpp
View File

@@ -80,12 +80,15 @@ bool operator==(const Structure& a, const Structure& b)
for (size_t i = 0; i < nflds; i++)
if (*(af[i].get()) != *(bf[i].get()))
return false;
return true;
StringArray an = a.getFieldNames();
StringArray bn = b.getFieldNames();
return std::equal( an.begin(), an.end(), bn.begin() );
}
bool operator==(const StructureArray& a, const StructureArray& b)
{
return a.getStructure()==b.getStructure();
return *(a.getStructure().get())==*(b.getStructure().get());
}
namespace nconvert {

128
pvDataApp/factory/Convert.cpp
View File

@@ -30,7 +30,7 @@ static String illegalScalarType("Illegal ScalarType");
static ConvertPtr convert;
template<typename T>
T toScalar(PVScalarPtr &pv)
T toScalar(PVScalarPtr const &pv)
{
ScalarConstPtr scalar = pv->getScalar();
ScalarType scalarType = scalar->getScalarType();
@@ -83,52 +83,52 @@ T toScalar(PVScalarPtr &pv)
throw std::logic_error(logicError);
}
int8 Convert::toByte(PVScalarPtr & pv)
int8 Convert::toByte(PVScalarPtr const & pv)
{
return toScalar<int8>(pv);
}
int16 Convert::toShort(PVScalarPtr & pv)
int16 Convert::toShort(PVScalarPtr const & pv)
{
return toScalar<int16>(pv);
}
int32 Convert::toInt(PVScalarPtr & pv)
int32 Convert::toInt(PVScalarPtr const & pv)
{
return toScalar<int32>(pv);
}
int64 Convert::toLong(PVScalarPtr & pv)
int64 Convert::toLong(PVScalarPtr const & pv)
{
return toScalar<int64>(pv);
}
uint8 Convert::toUByte(PVScalarPtr & pv)
uint8 Convert::toUByte(PVScalarPtr const & pv)
{
return toScalar<uint8>(pv);
}
uint16 Convert::toUShort(PVScalarPtr & pv)
uint16 Convert::toUShort(PVScalarPtr const & pv)
{
return toScalar<uint16>(pv);
}
uint32 Convert::toUInt(PVScalarPtr & pv)
uint32 Convert::toUInt(PVScalarPtr const & pv)
{
return toScalar<uint32>(pv);
}
uint64 Convert::toULong(PVScalarPtr &pv)
uint64 Convert::toULong(PVScalarPtr const &pv)
{
return toScalar<uint64>(pv);
}
float Convert::toFloat(PVScalarPtr &pv)
float Convert::toFloat(PVScalarPtr const &pv)
{
return toScalar<float>(pv);
}
double Convert::toDouble(PVScalarPtr& pv)
double Convert::toDouble(PVScalarPtr const & pv)
{
return toScalar<double>(pv);
}
@@ -222,7 +222,7 @@ String scalarToString<double>(double value)
}
template<typename T>
void fromScalar(PVScalarPtr &pv,T from)
void fromScalar(PVScalarPtr const &pv,T from)
{
ScalarConstPtr scalar = pv->getScalar();
ScalarType scalarType = scalar->getScalarType();
@@ -279,52 +279,52 @@ void fromScalar(PVScalarPtr &pv,T from)
throw std::logic_error(logicError);
}
void Convert::fromByte(PVScalarPtr &pv,int8 from)
void Convert::fromByte(PVScalarPtr const &pv,int8 from)
{
fromScalar<int8>(pv,from);
}
void Convert::fromShort(PVScalarPtr &pv,int16 from)
void Convert::fromShort(PVScalarPtr const &pv,int16 from)
{
fromScalar<int16>(pv,from);
}
void Convert::fromInt(PVScalarPtr &pv, int32 from)
void Convert::fromInt(PVScalarPtr const &pv, int32 from)
{
fromScalar<int32>(pv,from);
}
void Convert::fromLong(PVScalarPtr &pv, int64 from)
void Convert::fromLong(PVScalarPtr const &pv, int64 from)
{
fromScalar<int64>(pv,from);
}
void Convert::fromUByte(PVScalarPtr &pv,uint8 from)
void Convert::fromUByte(PVScalarPtr const &pv,uint8 from)
{
fromScalar<uint8>(pv,from);
}
void Convert::fromUShort(PVScalarPtr &pv,uint16 from)
void Convert::fromUShort(PVScalarPtr const &pv,uint16 from)
{
fromScalar<uint16>(pv,from);
}
void Convert::fromUInt(PVScalarPtr &pv, uint32 from)
void Convert::fromUInt(PVScalarPtr const &pv, uint32 from)
{
fromScalar<uint32>(pv,from);
}
void Convert::fromULong(PVScalarPtr &pv, uint64 from)
void Convert::fromULong(PVScalarPtr const &pv, uint64 from)
{
fromScalar<uint64>(pv,from);
}
void Convert::fromFloat(PVScalarPtr &pv, float from)
void Convert::fromFloat(PVScalarPtr const &pv, float from)
{
fromScalar<float>(pv,from);
}
void Convert::fromDouble(PVScalarPtr &pv, double from)
void Convert::fromDouble(PVScalarPtr const &pv, double from)
{
fromScalar<double>(pv,from);
}
@@ -414,7 +414,7 @@ Convert::Convert(){}
Convert::~Convert(){}
void Convert::getFullName(StringBuilder buf,PVFieldPtr & pvField)
void Convert::getFullName(StringBuilder buf,PVFieldPtr const & pvField)
{
buf->empty();
*buf += pvField->getFieldName();
@@ -429,7 +429,7 @@ void Convert::getFullName(StringBuilder buf,PVFieldPtr & pvField)
}
}
bool Convert::equals(PVFieldPtr &a,PVFieldPtr &b)
bool Convert::equals(PVFieldPtr const &a,PVFieldPtr const &b)
{
return convertEquals(a.get(),b.get());
}
@@ -439,12 +439,12 @@ bool Convert::equals(PVField &a,PVField &b)
return convertEquals(&a,&b);
}
void Convert::getString(StringBuilder buf,PVFieldPtr & pvField,int indentLevel)
void Convert::getString(StringBuilder buf,PVFieldPtr const & pvField,int indentLevel)
{
convertToString(buf,pvField.get(),indentLevel);
}
void Convert::getString(StringBuilder buf,PVFieldPtr & pvField)
void Convert::getString(StringBuilder buf,PVFieldPtr const & pvField)
{
convertToString(buf,pvField.get(),0);
}
@@ -459,7 +459,7 @@ void Convert::getString(StringBuilder buf,PVField *pvField)
convertToString(buf,pvField,0);
}
size_t Convert::fromString(PVStructurePtr &pvStructure, StringArray const & from, size_t fromStartIndex)
size_t Convert::fromString(PVStructurePtr const &pvStructure, StringArray const & from, size_t fromStartIndex)
{
size_t processed = 0;
@@ -500,7 +500,7 @@ size_t Convert::fromString(PVStructurePtr &pvStructure, StringArray const & from
}
void Convert::fromString(PVScalarPtr &pvScalar, String from)
void Convert::fromString(PVScalarPtr const &pvScalar, String from)
{
ScalarConstPtr scalar = pvScalar->getScalar();
ScalarType scalarType = scalar->getScalarType();
@@ -601,7 +601,7 @@ void Convert::fromString(PVScalarPtr &pvScalar, String from)
throw std::logic_error(message);
}
size_t Convert::fromString(PVScalarArrayPtr &pv, String from)
size_t Convert::fromString(PVScalarArrayPtr const &pv, String from)
{
if(from[0]=='[' && from[from.length()]==']') {
size_t offset = from.rfind(']');
@@ -620,19 +620,19 @@ size_t Convert::fromString(PVScalarArrayPtr &pv, String from)
return length;
}
size_t Convert::fromStringArray(PVScalarArrayPtr &pv, size_t offset, size_t length,
size_t Convert::fromStringArray(PVScalarArrayPtr const &pv, size_t offset, size_t length,
StringArray const & from, size_t fromOffset)
{
return convertFromStringArray(pv.get(),offset,length,from,fromOffset);
}
size_t Convert::toStringArray(PVScalarArrayPtr & pv, size_t offset, size_t length,
size_t Convert::toStringArray(PVScalarArrayPtr const & pv, size_t offset, size_t length,
StringArray const &to, size_t toOffset)
{
return convertToStringArray(pv.get(),offset,length,to,toOffset);
}
bool Convert::isCopyCompatible(FieldConstPtr &from, FieldConstPtr &to)
bool Convert::isCopyCompatible(FieldConstPtr const &from, FieldConstPtr const &to)
{
if(from->getType()!=to->getType()) return false;
switch(from->getType()) {
@@ -665,7 +665,7 @@ bool Convert::isCopyCompatible(FieldConstPtr &from, FieldConstPtr &to)
throw std::logic_error(message);
}
void Convert::copy(PVFieldPtr &from,PVFieldPtr &to)
void Convert::copy(PVFieldPtr const & from, PVFieldPtr const & to)
{
switch(from->getField()->getType()) {
case scalar:
@@ -700,7 +700,7 @@ void Convert::copy(PVFieldPtr &from,PVFieldPtr &to)
}
bool Convert::isCopyScalarCompatible(
ScalarConstPtr& fromField, ScalarConstPtr& toField)
ScalarConstPtr const & fromField, ScalarConstPtr const & toField)
{
ScalarType fromScalarType = fromField->getScalarType();
ScalarType toScalarType = toField->getScalarType();
@@ -712,7 +712,7 @@ bool Convert::isCopyScalarCompatible(
return false;
}
void Convert::copyScalar(PVScalarPtr &from, PVScalarPtr &to)
void Convert::copyScalar(PVScalarPtr const & from, PVScalarPtr const & to)
{
if(to->isImmutable()) {
if(from==to) return;
@@ -813,8 +813,8 @@ void Convert::copyScalar(PVScalarPtr &from, PVScalarPtr &to)
throw std::logic_error(message);
}
bool Convert::isCopyScalarArrayCompatible(ScalarArrayConstPtr &fromArray,
ScalarArrayConstPtr &toArray)
bool Convert::isCopyScalarArrayCompatible(ScalarArrayConstPtr const &fromArray,
ScalarArrayConstPtr const &toArray)
{
ScalarType fromType = fromArray->getElementType();
ScalarType toType = toArray->getElementType();
@@ -826,8 +826,8 @@ bool Convert::isCopyScalarArrayCompatible(ScalarArrayConstPtr &fromArray,
return false;
}
size_t Convert::copyScalarArray(PVScalarArrayPtr &from, size_t offset,
PVScalarArrayPtr &to, size_t toOffset, size_t length)
size_t Convert::copyScalarArray(PVScalarArrayPtr const & from, size_t offset,
PVScalarArrayPtr const & to, size_t toOffset, size_t length)
{
if(to->isImmutable()) {
@@ -920,7 +920,7 @@ size_t Convert::copyScalarArray(PVScalarArrayPtr &from, size_t offset,
}
bool Convert::isCopyStructureCompatible(
StructureConstPtr &fromStruct, StructureConstPtr &toStruct)
StructureConstPtr const &fromStruct, StructureConstPtr const &toStruct)
{
FieldConstPtrArray fromFields = fromStruct->getFields();
FieldConstPtrArray toFields = toStruct->getFields();
@@ -966,7 +966,7 @@ bool Convert::isCopyStructureCompatible(
return true;
}
void Convert::copyStructure(PVStructurePtr &from, PVStructurePtr &to)
void Convert::copyStructure(PVStructurePtr const & from, PVStructurePtr const & to)
{
if(to->isImmutable()) {
if(from==to) return;
@@ -1053,7 +1053,7 @@ void Convert::copyStructure(PVStructurePtr &from, PVStructurePtr &to)
}
bool Convert::isCopyStructureArrayCompatible(
StructureArrayConstPtr &from, StructureArrayConstPtr &to)
StructureArrayConstPtr const &from, StructureArrayConstPtr const &to)
{
StructureConstPtr xxx = from->getStructure();
StructureConstPtr yyy = to->getStructure();
@@ -1061,7 +1061,7 @@ bool Convert::isCopyStructureArrayCompatible(
}
void Convert::copyStructureArray(
PVStructureArrayPtr &from, PVStructureArrayPtr &to)
PVStructureArrayPtr const & from, PVStructureArrayPtr const & to)
{
if(to->isImmutable()) {
if(from==to) return;
@@ -1093,7 +1093,7 @@ void Convert::copyStructureArray(
to->postPut();
}
String Convert::toString(PVScalarPtr & pv)
String Convert::toString(PVScalarPtr const & pv)
{
static String trueString("true");
static String falseString("false");
@@ -1174,121 +1174,121 @@ String Convert::toString(PVScalarPtr & pv)
throw std::logic_error(logicError);
}
size_t Convert::toByteArray(PVScalarArrayPtr &pv, size_t offset, size_t length,
size_t Convert::toByteArray(PVScalarArrayPtr const &pv, size_t offset, size_t length,
int8 to[], size_t toOffset)
{
return convertToByteArray(pv.get(), offset, length, to, toOffset);
}
size_t Convert::toShortArray(PVScalarArrayPtr &pv, size_t offset, size_t length,
size_t Convert::toShortArray(PVScalarArrayPtr const &pv, size_t offset, size_t length,
int16 to[], size_t toOffset)
{
return convertToShortArray(pv.get(), offset, length, to, toOffset);
}
size_t Convert::toIntArray(PVScalarArrayPtr &pv, size_t offset, size_t length,
size_t Convert::toIntArray(PVScalarArrayPtr const &pv, size_t offset, size_t length,
int32 to[], size_t toOffset)
{
return convertToIntArray(pv.get(), offset, length, to, toOffset);
}
size_t Convert::toLongArray(PVScalarArrayPtr &pv, size_t offset, size_t length,
size_t Convert::toLongArray(PVScalarArrayPtr const &pv, size_t offset, size_t length,
int64 to[], size_t toOffset)
{
return convertToLongArray(pv.get(), offset, length, to, toOffset);
}
size_t Convert::toUByteArray(PVScalarArrayPtr &pv, size_t offset, size_t length,
size_t Convert::toUByteArray(PVScalarArrayPtr const &pv, size_t offset, size_t length,
uint8 to[], size_t toOffset)
{
return convertToUByteArray(pv.get(), offset, length, to, toOffset);
}
size_t Convert::toUShortArray(PVScalarArrayPtr &pv, size_t offset, size_t length,
size_t Convert::toUShortArray(PVScalarArrayPtr const &pv, size_t offset, size_t length,
uint16 to[], size_t toOffset)
{
return convertToUShortArray(pv.get(), offset, length, to, toOffset);
}
size_t Convert::toUIntArray(PVScalarArrayPtr &pv, size_t offset, size_t length,
size_t Convert::toUIntArray(PVScalarArrayPtr const &pv, size_t offset, size_t length,
uint32 to[], size_t toOffset)
{
return convertToUIntArray(pv.get(), offset, length, to, toOffset);
}
size_t Convert::toULongArray(PVScalarArrayPtr &pv, size_t offset, size_t length,
size_t Convert::toULongArray(PVScalarArrayPtr const &pv, size_t offset, size_t length,
uint64 to[], size_t toOffset)
{
return convertToULongArray(pv.get(), offset, length, to, toOffset);
}
size_t Convert::toFloatArray(PVScalarArrayPtr &pv, size_t offset, size_t length,
size_t Convert::toFloatArray(PVScalarArrayPtr const &pv, size_t offset, size_t length,
float to[], size_t toOffset)
{
return convertToFloatArray(pv.get(), offset, length, to, toOffset);
}
size_t Convert::toDoubleArray(PVScalarArrayPtr &pv, size_t offset, size_t length,
size_t Convert::toDoubleArray(PVScalarArrayPtr const &pv, size_t offset, size_t length,
double to[], size_t toOffset)
{
return convertToDoubleArray(pv.get(), offset, length, to, toOffset);
}
size_t Convert::fromByteArray(PVScalarArrayPtr &pv, size_t offset, size_t length,
size_t Convert::fromByteArray(PVScalarArrayPtr const &pv, size_t offset, size_t length,
int8 from[], size_t fromOffset)
{
return convertFromByteArray(pv.get(), offset, length, from, fromOffset);
}
size_t Convert::fromShortArray(PVScalarArrayPtr &pv, size_t offset, size_t length,
size_t Convert::fromShortArray(PVScalarArrayPtr const &pv, size_t offset, size_t length,
int16 from[], size_t fromOffset)
{
return convertFromShortArray(pv.get(), offset, length, from, fromOffset);
}
size_t Convert::fromIntArray(PVScalarArrayPtr &pv, size_t offset, size_t length,
size_t Convert::fromIntArray(PVScalarArrayPtr const &pv, size_t offset, size_t length,
int32 from[], size_t fromOffset)
{
return convertFromIntArray(pv.get(), offset, length, from, fromOffset);
}
size_t Convert::fromLongArray(PVScalarArrayPtr &pv, size_t offset, size_t length,
size_t Convert::fromLongArray(PVScalarArrayPtr const &pv, size_t offset, size_t length,
int64 from[], size_t fromOffset)
{
return convertFromLongArray(pv.get(), offset, length, from, fromOffset);
}
size_t Convert::fromUByteArray(PVScalarArrayPtr &pv, size_t offset, size_t length,
size_t Convert::fromUByteArray(PVScalarArrayPtr const &pv, size_t offset, size_t length,
uint8 from[], size_t fromOffset)
{
return convertFromUByteArray(pv.get(), offset, length, from, fromOffset);
}
size_t Convert::fromUShortArray(PVScalarArrayPtr &pv, size_t offset, size_t length,
size_t Convert::fromUShortArray(PVScalarArrayPtr const &pv, size_t offset, size_t length,
uint16 from[], size_t fromOffset)
{
return convertFromUShortArray(pv.get(), offset, length, from, fromOffset);
}
size_t Convert::fromUIntArray(PVScalarArrayPtr &pv, size_t offset, size_t length,
size_t Convert::fromUIntArray(PVScalarArrayPtr const &pv, size_t offset, size_t length,
uint32 from[], size_t fromOffset)
{
return convertFromUIntArray(pv.get(), offset, length, from, fromOffset);
}
size_t Convert::fromULongArray(PVScalarArrayPtr &pv, size_t offset, size_t length,
size_t Convert::fromULongArray(PVScalarArrayPtr const &pv, size_t offset, size_t length,
uint64 from[], size_t fromOffset)
{
return convertFromULongArray(pv.get(), offset, length, from, fromOffset);
}
size_t Convert::fromFloatArray(PVScalarArrayPtr &pv, size_t offset, size_t length,
size_t Convert::fromFloatArray(PVScalarArrayPtr const &pv, size_t offset, size_t length,
float from[], size_t fromOffset)
{
return convertFromFloatArray(pv.get(), offset, length, from, fromOffset);
}
size_t Convert::fromDoubleArray(PVScalarArrayPtr &pv, size_t offset, size_t length,
size_t Convert::fromDoubleArray(PVScalarArrayPtr const &pv, size_t offset, size_t length,
double from[], size_t fromOffset)
{
return convertFromDoubleArray(pv.get(), offset, length, from, fromOffset);

12
pvDataApp/factory/FieldCreateFactory.cpp
View File

@@ -117,8 +117,8 @@ static StructureConstPtr deserializeStructureField(const FieldCreate* fieldCreat
StringArray fieldNames; fieldNames.reserve(size);
for (std::size_t i = 0; i < size; i++)
{
fieldNames[i] = SerializeHelper::deserializeString(buffer, control);
fields[i] = control->cachedDeserialize(buffer);
fieldNames.push_back(SerializeHelper::deserializeString(buffer, control));
fields.push_back(control->cachedDeserialize(buffer));
}
return fieldCreate->createStructure(fieldNames, fields);
@@ -143,7 +143,7 @@ void ScalarArray::deserialize(ByteBuffer *buffer, DeserializableControl *control
throw std::runtime_error("not valid operation, use FieldCreate::deserialize instead");
}
StructureArray::StructureArray(StructureConstPtr structure)
StructureArray::StructureArray(StructureConstPtr const & structure)
: Field(structureArray),pstructure(structure)
{
}
@@ -289,7 +289,7 @@ StructureConstPtr FieldCreate::createStructure (
}
StructureArrayConstPtr FieldCreate::createStructureArray(
StructureConstPtr structure) const
StructureConstPtr const & structure) const
{
StructureArrayConstPtr structureArray(
new StructureArray(structure), Field::Deleter());
@@ -297,7 +297,7 @@ StructureArrayConstPtr FieldCreate::createStructureArray(
}
StructureConstPtr FieldCreate::appendField(
StructureConstPtr structure,String fieldName, FieldConstPtr field) const
StructureConstPtr const & structure,String fieldName, FieldConstPtr const & field) const
{
StringArray oldNames = structure->getFieldNames();
FieldConstPtrArray oldFields = structure->getFields();
@@ -314,7 +314,7 @@ StructureConstPtr FieldCreate::appendField(
}
StructureConstPtr FieldCreate::appendFields(
StructureConstPtr structure,
StructureConstPtr const & structure,
StringArray const & fieldNames,
FieldConstPtrArray const & fields) const
{

2
pvDataApp/factory/PVArray.cpp
View File

@@ -25,7 +25,7 @@ namespace epics { namespace pvData {
bool capacityMutable;
};
PVArray::PVArray(FieldConstPtr field)
PVArray::PVArray(FieldConstPtr const & field)
: PVField(field),pImpl(new PVArrayPvt())
{ }

32
pvDataApp/factory/PVDataCreateFactory.cpp
View File

@@ -36,7 +36,7 @@ public:
typedef T* pointer;
typedef const T* const_pointer;
BasePVScalar(ScalarConstPtr &scalar);
BasePVScalar(ScalarConstPtr const & scalar);
virtual ~BasePVScalar();
virtual T get();
virtual void put(T val);
@@ -49,7 +49,7 @@ private:
};
template<typename T>
BasePVScalar<T>::BasePVScalar(ScalarConstPtr &scalar)
BasePVScalar<T>::BasePVScalar(ScalarConstPtr const & scalar)
: PVScalarValue<T>(scalar),value(0)
{}
//Note: '0' is a suitable default for all POD types (not String)
@@ -97,7 +97,7 @@ public:
typedef String* pointer;
typedef const String* const_pointer;
BasePVString(ScalarConstPtr &scalar);
BasePVString(ScalarConstPtr const & scalar);
virtual ~BasePVString();
virtual String get();
virtual void put(String val);
@@ -111,7 +111,7 @@ private:
String value;
};
BasePVString::BasePVString(ScalarConstPtr &scalar)
BasePVString::BasePVString(ScalarConstPtr const & scalar)
: PVString(scalar),value()
{}
@@ -159,7 +159,7 @@ public:
typedef std::vector<T> vector;
typedef std::tr1::shared_ptr<vector> shared_vector;
DefaultPVArray(ScalarArrayConstPtr &scalarArray);
DefaultPVArray(ScalarArrayConstPtr const & scalarArray);
virtual ~DefaultPVArray();
virtual void setCapacity(size_t capacity);
virtual size_t get(size_t offset, size_t length, PVArrayData<T> &data) ;
@@ -200,7 +200,7 @@ T *DefaultPVArray<T>::get() const
template<typename T>
DefaultPVArray<T>::DefaultPVArray(ScalarArrayConstPtr &scalarArray)
DefaultPVArray<T>::DefaultPVArray(ScalarArrayConstPtr const & scalarArray)
: PVValueArray<T>(scalarArray),
value(std::tr1::shared_ptr<std::vector<T> >(new std::vector<T>()))
@@ -425,7 +425,7 @@ typedef DefaultPVArray<String> BasePVStringArray;
PVDataCreate::PVDataCreate(){ }
PVFieldPtr PVDataCreate::createPVField(FieldConstPtr & field)
PVFieldPtr PVDataCreate::createPVField(FieldConstPtr const & field)
{
switch(field->getType()) {
case scalar: {
@@ -448,7 +448,7 @@ PVFieldPtr PVDataCreate::createPVField(FieldConstPtr & field)
throw std::logic_error("PVDataCreate::createPVField should never get here");
}
PVFieldPtr PVDataCreate::createPVField(PVFieldPtr & fieldToClone)
PVFieldPtr PVDataCreate::createPVField(PVFieldPtr const & fieldToClone)
{
switch(fieldToClone->getField()->getType()) {
case scalar:
@@ -484,7 +484,7 @@ PVFieldPtr PVDataCreate::createPVField(PVFieldPtr & fieldToClone)
throw std::logic_error("PVDataCreate::createPVField should never get here");
}
PVScalarPtr PVDataCreate::createPVScalar(ScalarConstPtr & scalar)
PVScalarPtr PVDataCreate::createPVScalar(ScalarConstPtr const & scalar)
{
ScalarType scalarType = scalar->getScalarType();
switch(scalarType) {
@@ -523,7 +523,7 @@ PVScalarPtr PVDataCreate::createPVScalar(ScalarType scalarType)
}
PVScalarPtr PVDataCreate::createPVScalar(PVScalarPtr & scalarToClone)
PVScalarPtr PVDataCreate::createPVScalar(PVScalarPtr const & scalarToClone)
{
ScalarType scalarType = scalarToClone->getScalar()->getScalarType();
PVScalarPtr pvScalar = createPVScalar(scalarType);
@@ -542,7 +542,7 @@ PVScalarPtr PVDataCreate::createPVScalar(PVScalarPtr & scalarToClone)
}
PVScalarArrayPtr PVDataCreate::createPVScalarArray(
ScalarArrayConstPtr & scalarArray)
ScalarArrayConstPtr const & scalarArray)
{
switch(scalarArray->getElementType()) {
case pvBoolean:
@@ -582,7 +582,7 @@ PVScalarArrayPtr PVDataCreate::createPVScalarArray(
}
PVScalarArrayPtr PVDataCreate::createPVScalarArray(
PVScalarArrayPtr &arrayToClone)
PVScalarArrayPtr const & arrayToClone)
{
PVScalarArrayPtr pvArray = createPVScalarArray(
arrayToClone->getScalarArray()->getElementType());
@@ -601,19 +601,19 @@ PVScalarArrayPtr PVDataCreate::createPVScalarArray(
}
PVStructureArrayPtr PVDataCreate::createPVStructureArray(
StructureArrayConstPtr & structureArray)
StructureArrayConstPtr const & structureArray)
{
return PVStructureArrayPtr(new PVStructureArray(structureArray));
}
PVStructurePtr PVDataCreate::createPVStructure(
StructureConstPtr &structure)
StructureConstPtr const & structure)
{
return PVStructurePtr(new PVStructure(structure));
}
PVStructurePtr PVDataCreate::createPVStructure(
StringArray & fieldNames,PVFieldPtrArray & pvFields)
StringArray const & fieldNames,PVFieldPtrArray const & pvFields)
{
size_t num = fieldNames.size();
FieldConstPtrArray fields(num);
@@ -622,7 +622,7 @@ PVStructurePtr PVDataCreate::createPVStructure(
return PVStructurePtr(new PVStructure(structure,pvFields));
}
PVStructurePtr PVDataCreate::createPVStructure(PVStructurePtr &structToClone)
PVStructurePtr PVDataCreate::createPVStructure(PVStructurePtr const & structToClone)
{
FieldConstPtrArray field;
if(structToClone==0) {

2
pvDataApp/factory/PVScalar.cpp
View File

@@ -17,7 +17,7 @@ namespace epics { namespace pvData {
PVScalar::~PVScalar() {}
PVScalar::PVScalar(ScalarConstPtr scalar)
PVScalar::PVScalar(ScalarConstPtr const & scalar)
: PVField(scalar) {}
ScalarConstPtr PVScalar::getScalar()

2
pvDataApp/factory/PVScalarArray.cpp
View File

@@ -17,7 +17,7 @@ namespace epics { namespace pvData {
PVScalarArray::~PVScalarArray() {}
PVScalarArray::PVScalarArray(ScalarArrayConstPtr scalarArray)
PVScalarArray::PVScalarArray(ScalarArrayConstPtr const & scalarArray)
: PVArray(scalarArray) {}
ScalarArrayConstPtr PVScalarArray::getScalarArray()

10
pvDataApp/factory/PVStructure.cpp
View File

@@ -40,7 +40,7 @@ static PVScalarArrayPtr nullPVScalarArray;
static PVFieldPtr findSubField(String fieldName,PVStructure *pvStructure);
PVStructure::PVStructure(StructureConstPtr& structurePtr)
PVStructure::PVStructure(StructureConstPtr const & structurePtr)
: PVField(structurePtr),
structurePtr(structurePtr),
extendsStructureName("")
@@ -58,8 +58,8 @@ PVStructure::PVStructure(StructureConstPtr& structurePtr)
}
}
PVStructure::PVStructure(StructureConstPtr structurePtr,
PVFieldPtrArray & pvs
PVStructure::PVStructure(StructureConstPtr const & structurePtr,
PVFieldPtrArray const & pvs
)
: PVField(structurePtr),
structurePtr(structurePtr),
@@ -112,7 +112,7 @@ PVFieldPtr PVStructure::getSubField(size_t fieldOffset)
throw std::logic_error("PVStructure.getSubField: Logic error");
}
void PVStructure::appendPVField(String fieldName,PVFieldPtr & pvField )
void PVStructure::appendPVField(String fieldName, PVFieldPtr const & pvField)
{
size_t origLength = pvFields.size();
size_t newLength = origLength+1;
@@ -132,7 +132,7 @@ void PVStructure::appendPVField(String fieldName,PVFieldPtr & pvField )
}
}
void PVStructure::appendPVFields(StringArray &fieldNames,PVFieldPtrArray &pvFields)
void PVStructure::appendPVFields(StringArray const & fieldNames, PVFieldPtrArray const & pvFields)
{
size_t origLength = this->pvFields.size();
size_t extra = fieldNames.size();

2
pvDataApp/factory/PVStructureArray.cpp
View File

@@ -19,7 +19,7 @@ using std::size_t;
namespace epics { namespace pvData {
PVStructureArray::PVStructureArray(StructureArrayConstPtr structureArray)
PVStructureArray::PVStructureArray(StructureArrayConstPtr const & structureArray)
: PVArray(structureArray),
structureArray(structureArray),
value(std::tr1::shared_ptr<std::vector<PVStructurePtr> >

2
pvDataApp/factory/StandardField.cpp
View File

@@ -505,7 +505,7 @@ StructureConstPtr StandardField::scalarArray(
StructureConstPtr StandardField::structureArray(
StructureConstPtr &structure,String properties)
StructureConstPtr const & structure,String properties)
{
StructureArrayConstPtr field = fieldCreate->createStructureArray(
structure);

124
pvDataApp/pv/convert.h
View File

@@ -73,7 +73,7 @@ public:
* @param builder The builder that will have the result.
* @param pvField The pvField.
*/
void getFullName(StringBuilder buf,PVFieldPtr & pvField);
void getFullName(StringBuilder buf,PVFieldPtr const & pvField);
/**
* Do fields have the same definition.
*
@@ -81,7 +81,7 @@ public:
* @param Second field
* @return (false, true) if the fields (are not, are) the same.
*/
bool equals(PVFieldPtr &a,PVFieldPtr &b);
bool equals(PVFieldPtr const &a,PVFieldPtr const &b);
/**
* Do fields have the same definition.
*
@@ -97,14 +97,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,PVFieldPtr & pvField,int indentLevel);
void getString(StringBuilder buf,PVFieldPtr 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,PVFieldPtr & pvField);
void getString(StringBuilder buf,PVFieldPtr const & pvField);
/**
* Convert a PVField to a string.
* @param buf buffer for the result
@@ -127,14 +127,14 @@ 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 &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.
* @param from The String value to convert and put into a PV.
* @throws std::logic_error if the String does not have a valid value.
*/
void fromString(PVScalarPtr & pv, String from);
void fromString(PVScalarPtr const & pv, String from);
/**
* Convert from a String to a PVScalarArray.
* The String must be a comma separated set of values optionally enclosed in []
@@ -144,7 +144,7 @@ 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 array values.
*/
std::size_t fromString(PVScalarArrayPtr & pv, String from);
std::size_t fromString(PVScalarArrayPtr const & pv, String from);
/**
* Convert a PVScalarArray from a String array.
* The array element type must be a scalar.
@@ -157,7 +157,7 @@ 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 & pv, std::size_t offset, std::size_t length,
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.
@@ -168,7 +168,7 @@ public:
* @param toOffset Starting element in the string array.
* @return Number of elements converted.
*/
std::size_t toStringArray(PVScalarArrayPtr & pv, std::size_t offset, std::size_t length,
std::size_t toStringArray(PVScalarArrayPtr const & pv, std::size_t offset, std::size_t length,
StringArray const & to, std::size_t toOffset);
/**
* Are from and to valid arguments to copy.
@@ -179,7 +179,7 @@ public:
* @param to The destination.
* @return (false,true) is the arguments (are not, are) compatible.
*/
bool isCopyCompatible(FieldConstPtr & from, FieldConstPtr & to);
bool isCopyCompatible(FieldConstPtr const & from, FieldConstPtr const & to);
/**
* Copy from a PVField to another PVField.
* This calls one on copyScalar, copyArray, copyStructure.
@@ -188,7 +188,7 @@ public:
* @param to The destination
* @throws std::invalid_argument if the arguments are not compatible.
*/
void copy(PVFieldPtr & from,PVFieldPtr & to);
void copy(PVFieldPtr const & from, PVFieldPtr const & to);
/**
* Are from and to valid arguments to copyScalar.
* false will be returned if either argument is not a scalar as defined by Type.isScalar().
@@ -203,14 +203,14 @@ public:
* @return (false,true) If the arguments (are not, are) compatible.
*/
bool isCopyScalarCompatible(
ScalarConstPtr & from, ScalarConstPtr & to);
ScalarConstPtr const & from, ScalarConstPtr const & to);
/**
* Copy from a scalar pv to another scalar pv.
* @param from the source.
* @param to the destination.
* @throws std::invalid_argument if the arguments are not compatible.
*/
void copyScalar(PVScalarPtr & from, PVScalarPtr & to);
void copyScalar(PVScalarPtr const & from, PVScalarPtr const & to);
/**
* Are from and to valid arguments to copyArray.
* The results are like isCopyScalarCompatible except that the tests are made on the elementType.
@@ -218,8 +218,8 @@ public:
* @param to The to array.
* @return (false,true) If the arguments (are not, are) compatible.
*/
bool isCopyScalarArrayCompatible(ScalarArrayConstPtr & from,
ScalarArrayConstPtr & to);
bool isCopyScalarArrayCompatible(ScalarArrayConstPtr const & from,
ScalarArrayConstPtr const & to);
/**
* Convert from a source PV array to a destination PV array.
* @param from The source array.
@@ -230,8 +230,8 @@ public:
* @return Number of elements converted.
* @throws std::invalid_argument if the arguments are not compatible.
*/
std::size_t copyScalarArray(PVScalarArrayPtr & from, std::size_t offset,
PVScalarArrayPtr & 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.
@@ -240,7 +240,7 @@ public:
* @return (false,true) If the arguments (are not, are) compatible.
*/
bool isCopyStructureCompatible(
StructureConstPtr & from, StructureConstPtr & to);
StructureConstPtr const & from, StructureConstPtr const & to);
/**
* Copy from a structure pv to another structure pv.
* NOTE: Only compatible nodes are copied. This means:
@@ -254,7 +254,7 @@ public:
* @param to The destination.
* @throws std::invalid_argument if the arguments are not compatible.
*/
void copyStructure(PVStructurePtr & from, PVStructurePtr & to);
void copyStructure(PVStructurePtr const & from, PVStructurePtr const & to);
/**
* Are from and to valid for copyStructureArray.
* @param from The from StructureArray.
@@ -262,158 +262,158 @@ public:
* @return (false,true) If the arguments (are not, are) compatible.
*/
bool isCopyStructureArrayCompatible(
StructureArrayConstPtr & from, StructureArrayConstPtr & to);
StructureArrayConstPtr const & from, StructureArrayConstPtr const & to);
/**
* Copy from a structure array to another structure array.
* @param from The source array.
* @param to The destination array.
*/
void copyStructureArray(
PVStructureArrayPtr & from, PVStructureArrayPtr & to);
PVStructureArrayPtr const & from, PVStructureArrayPtr const & to);
/**
* Convert a PV to a <byte>.
* @param pv a PV
* @return converted value
*/
int8 toByte(PVScalarPtr & pv);
int8 toByte(PVScalarPtr const & pv);
/**
* Convert a PV to a short.
* @param pv a PV
* @return converted value
* @throws std::invalid_argument if the Type is not a numeric scalar
*/
int16 toShort(PVScalarPtr & pv);
int16 toShort(PVScalarPtr const & pv);
/**
* Convert a PV to a int.
* @param pv a PV
* @return converted value
* @throws std::invalid_argument if the Type is not a numeric scalar
*/
int32 toInt(PVScalarPtr & pv);
int32 toInt(PVScalarPtr const & pv);
/**
* Convert a PV to an long
* @param pv a PV
* @return converted value
* @throws std::invalid_argument if the Type is not a numeric scalar
*/
int64 toLong(PVScalarPtr & pv);
int64 toLong(PVScalarPtr const & pv);
/**
* Convert a PV to a ubyte.
* @param pv a PV
* @return converted value
*/
uint8 toUByte(PVScalarPtr & pv);
uint8 toUByte(PVScalarPtr const & pv);
/**
* Convert a PV to a ushort.
* @param pv a PV
* @return converted value
* @throws std::invalid_argument if the Type is not a numeric scalar
*/
uint16 toUShort(PVScalarPtr & pv);
uint16 toUShort(PVScalarPtr const & pv);
/**
* Convert a PV to a uint.
* @param pv a PV
* @return converted value
* @throws std::invalid_argument if the Type is not a numeric scalar
*/
uint32 toUInt(PVScalarPtr & pv);
uint32 toUInt(PVScalarPtr const & pv);
/**
* Convert a PV to an ulong
* @param pv a PV
* @return converted value
* @throws std::invalid_argument if the Type is not a numeric scalar
*/
uint64 toULong(PVScalarPtr & pv);
uint64 toULong(PVScalarPtr const & pv);
/**
* Convert a PV to a float
* @param pv a PV
* @return converted value
* @throws std::invalid_argument if the Type is not a numeric scalar
*/
float toFloat(PVScalarPtr & pv);
float toFloat(PVScalarPtr const & pv);
/**
* Convert a PV to a double
* @param pv a PV
* @return converted value
* @throws std::invalid_argument if the Type is not a numeric scalar
*/
double toDouble(PVScalarPtr & pv);
double toDouble(PVScalarPtr const & pv);
/**
* Convert a PV to a String
* @param pv a PV
* @return converted value
*/
String toString(PVScalarPtr & pv);
String toString(PVScalarPtr const & pv);
/**
* Convert a PV from a byte
* @param pv a PV
* @param from value to put into PV
* @throws std::invalid_argument if the Type is not a numeric scalar
*/
void fromByte(PVScalarPtr & pv,int8 from);
void fromByte(PVScalarPtr const & pv,int8 from);
/**
* Convert a PV from a short
* @param pv a PV
* @param from value to put into PV
* @throws std::invalid_argument if the Type is not a numeric scalar
*/
void fromShort(PVScalarPtr & pv,int16 from);
void fromShort(PVScalarPtr const & pv,int16 from);
/**
* Convert a PV from an int
* @param pv a PV
* @param from value to put into PV
* @throws std::invalid_argument if the Type is not a numeric scalar
*/
void fromInt(PVScalarPtr & pv, int32 from);
void fromInt(PVScalarPtr const & pv, int32 from);
/**
* Convert a PV from a long
* @param pv a PV
* @param from value to put into PV
* @throws std::invalid_argument if the Type is not a numeric scalar
*/
void fromLong(PVScalarPtr & pv, int64 from);
void fromLong(PVScalarPtr const & pv, int64 from);
/**
* Convert a PV from a ubyte
* @param pv a PV
* @param from value to put into PV
* @throws std::invalid_argument if the Type is not a numeric scalar
*/
void fromUByte(PVScalarPtr & pv,uint8 from);
void fromUByte(PVScalarPtr const & pv,uint8 from);
/**
* Convert a PV from a ushort
* @param pv a PV
* @param from value to put into PV
* @throws std::invalid_argument if the Type is not a numeric scalar
*/
void fromUShort(PVScalarPtr & pv,uint16 from);
void fromUShort(PVScalarPtr const & pv,uint16 from);
/**
* Convert a PV from an uint
* @param pv a PV
* @param from value to put into PV
* @throws std::invalid_argument if the Type is not a numeric scalar
*/
void fromUInt(PVScalarPtr & pv, uint32 from);
void fromUInt(PVScalarPtr const & pv, uint32 from);
/**
* Convert a PV from a ulong
* @param pv a PV
* @param from value to put into PV
* @throws std::invalid_argument if the Type is not a numeric scalar
*/
void fromULong(PVScalarPtr & pv, uint64 from);
void fromULong(PVScalarPtr const & pv, uint64 from);
/**
* Convert a PV from a float
* @param pv a PV
* @param from value to put into PV
* @throws std::invalid_argument if the Type is not a numeric scalar
*/
void fromFloat(PVScalarPtr & pv, float from);
void fromFloat(PVScalarPtr const & pv, float from);
/**
* Convert a PV from a double
* @param pv a PV
* @param from value to put into PV
* @throws std::invalid_argument if the Type is not a numeric scalar
*/
void fromDouble(PVScalarPtr & pv, double from);
void fromDouble(PVScalarPtr const & pv, double from);
/**
* Convert a PV array to a byte array.
* @param pv a PV
@@ -424,7 +424,7 @@ public:
* @return number of elements converted
* @throws std::invalid_argument if the element type is not numeric
*/
std::size_t toByteArray(PVScalarArrayPtr & pv, std::size_t offset, std::size_t length,
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.
@@ -436,7 +436,7 @@ public:
* @return number of elements converted
* @throws std::invalid_argument if the element type is not numeric
*/
std::size_t toShortArray(PVScalarArrayPtr & pv, std::size_t offset, std::size_t length,
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.
@@ -448,7 +448,7 @@ public:
* @return number of elements converted
* @throws std::invalid_argument if the element type is not numeric
*/
std::size_t toIntArray(PVScalarArrayPtr & pv, std::size_t offset, std::size_t length,
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.
@@ -460,7 +460,7 @@ public:
* @return number of elements converted
* @throws std::invalid_argument if the element type is not numeric
*/
std::size_t toLongArray(PVScalarArrayPtr & pv, std::size_t offset, std::size_t length,
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.
@@ -472,7 +472,7 @@ public:
* @return number of elements converted
* @throws std::invalid_argument if the element type is not numeric
*/
std::size_t toUByteArray(PVScalarArrayPtr & pv, std::size_t offset, std::size_t length,
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.
@@ -484,7 +484,7 @@ public:
* @return number of elements converted
* @throws std::invalid_argument if the element type is not numeric
*/
std::size_t toUShortArray(PVScalarArrayPtr & pv, std::size_t offset, std::size_t length,
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.
@@ -496,7 +496,7 @@ public:
* @return number of elements converted
* @throws std::invalid_argument if the element type is not numeric
*/
std::size_t toUIntArray(PVScalarArrayPtr & pv, std::size_t offset, std::size_t length,
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.
@@ -508,7 +508,7 @@ public:
* @return number of elements converted
* @throws std::invalid_argument if the element type is not numeric
*/
std::size_t toULongArray(PVScalarArrayPtr & pv, std::size_t offset, std::size_t length,
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.
@@ -520,7 +520,7 @@ public:
* @return number of elements converted
* @throws std::invalid_argument if the element type is not numeric
*/
std::size_t toFloatArray(PVScalarArrayPtr & pv, std::size_t offset, std::size_t length,
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.
@@ -532,7 +532,7 @@ public:
* @return number of elements converted
* @throws std::invalid_argument if the element type is not numeric
*/
std::size_t toDoubleArray(PVScalarArrayPtr & pv, std::size_t offset, std::size_t length,
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.
@@ -544,7 +544,7 @@ public:
* @return number of elements converted
* @throws std::invalid_argument if the element type is not numeric
*/
std::size_t fromByteArray(PVScalarArrayPtr & pv, std::size_t offset, std::size_t length,
std::size_t fromByteArray(PVScalarArrayPtr const & pv, std::size_t offset, std::size_t length,
int8* frim, std::size_t fromOffset);
/**
* Convert a PV array from a short array.
@@ -556,7 +556,7 @@ public:
* @return number of elements converted
* @throws std::invalid_argument if the element type is not numeric
*/
std::size_t fromShortArray(PVScalarArrayPtr & pv, std::size_t offset, std::size_t length,
std::size_t fromShortArray(PVScalarArrayPtr const & pv, std::size_t offset, std::size_t length,
int16* frim, std::size_t fromOffset);
/**
* Convert a PV array from an int array.
@@ -568,7 +568,7 @@ public:
* @return number of elements converted
* @throws std::invalid_argument if the element type is not numeric
*/
std::size_t fromIntArray(PVScalarArrayPtr & pv, std::size_t offset, std::size_t length,
std::size_t fromIntArray(PVScalarArrayPtr const & pv, std::size_t offset, std::size_t length,
int32* frim, std::size_t fromOffset);
/**
* Convert a PV array from a long array.
@@ -580,7 +580,7 @@ public:
* @return number of elements converted
* @throws std::invalid_argument if the element type is not numeric
*/
std::size_t fromLongArray(PVScalarArrayPtr & pv, std::size_t offset, std::size_t length,
std::size_t fromLongArray(PVScalarArrayPtr const & pv, std::size_t offset, std::size_t length,
int64* frim, std::size_t fromOffset);
/**
* Convert a PV array from a ubyte array.
@@ -592,7 +592,7 @@ public:
* @return number of elements converted
* @throws std::invalid_argument if the element type is not numeric
*/
std::size_t fromUByteArray(PVScalarArrayPtr & pv, std::size_t offset, std::size_t length,
std::size_t fromUByteArray(PVScalarArrayPtr const & pv, std::size_t offset, std::size_t length,
uint8* frim, std::size_t fromOffset);
/**
* Convert a PV array from a ushort array.
@@ -604,7 +604,7 @@ public:
* @return number of elements converted
* @throws std::invalid_argument if the element type is not numeric
*/
std::size_t fromUShortArray(PVScalarArrayPtr & pv, std::size_t offset, std::size_t length,
std::size_t fromUShortArray(PVScalarArrayPtr const & pv, std::size_t offset, std::size_t length,
uint16* frim, std::size_t fromOffset);
/**
* Convert a PV array from an uint array.
@@ -616,7 +616,7 @@ public:
* @return number of elements converted
* @throws std::invalid_argument if the element type is not numeric
*/
std::size_t fromUIntArray(PVScalarArrayPtr & pv, std::size_t offset, std::size_t length,
std::size_t fromUIntArray(PVScalarArrayPtr const & pv, std::size_t offset, std::size_t length,
uint32* frim, std::size_t fromOffset);
/**
* Convert a PV array from a ulong array.
@@ -628,7 +628,7 @@ public:
* @return number of elements converted
* @throws std::invalid_argument if the element type is not numeric
*/
std::size_t fromULongArray(PVScalarArrayPtr & pv, std::size_t offset, std::size_t length,
std::size_t fromULongArray(PVScalarArrayPtr const & pv, std::size_t offset, std::size_t length,
uint64* frim, std::size_t fromOffset);
/**
* Convert a PV array from a float array.
@@ -640,7 +640,7 @@ public:
* @return number of elements converted
* @throws std::invalid_argument if the element type is not numeric
*/
std::size_t fromFloatArray(PVScalarArrayPtr & pv, std::size_t offset, std::size_t length,
std::size_t fromFloatArray(PVScalarArrayPtr const & pv, std::size_t offset, std::size_t length,
float* frim, std::size_t fromOffset);
/**
* Convert a PV array from a double array.
@@ -652,7 +652,7 @@ public:
* @return number of elements converted
* @throws std::invalid_argument if the element type is not numeric
*/
std::size_t fromDoubleArray(PVScalarArrayPtr & pv, std::size_t offset, std::size_t length,
std::size_t fromDoubleArray(PVScalarArrayPtr const & pv, std::size_t offset, std::size_t length,
double* frim, std::size_t fromOffset);
/**
* Convenience method for implementing toString.

47
pvDataApp/pv/pvData.h
View File

@@ -292,7 +292,7 @@ public:
*/
ScalarConstPtr getScalar() ;
protected:
PVScalar(ScalarConstPtr scalar);
PVScalar(ScalarConstPtr const & scalar);
};
/**
@@ -320,7 +320,7 @@ public:
*/
virtual void put(T value) = 0;
protected:
PVScalarValue(ScalarConstPtr scalar)
PVScalarValue(ScalarConstPtr const & scalar)
: PVScalar(scalar) {}
private:
friend class PVDataCreate;
@@ -362,7 +362,7 @@ public:
*/
virtual ~PVString() {}
protected:
PVString(ScalarConstPtr & scalar)
PVString(ScalarConstPtr const & scalar)
: PVScalarValue<String>(scalar) {}
};
typedef std::tr1::shared_ptr<PVString> PVStringPtr;
@@ -409,7 +409,7 @@ public:
*/
virtual void setCapacity(std::size_t capacity) = 0;
protected:
PVArray(FieldConstPtr field);
PVArray(FieldConstPtr const & field);
void setCapacityLength(std::size_t capacity,std::size_t length);
private:
class PVArrayPvt * pImpl;
@@ -461,7 +461,7 @@ public:
ScalarArrayConstPtr getScalarArray() ;
protected:
PVScalarArray(ScalarArrayConstPtr scalarArray);
PVScalarArray(ScalarArrayConstPtr const & scalarArray);
private:
friend class PVDataCreate;
};
@@ -552,7 +552,7 @@ public:
virtual vector const & getVector() {return *value;}
virtual shared_vector const & getSharedVector() {return value;}
protected:
PVStructureArray( StructureArrayConstPtr structureArray);
PVStructureArray(StructureArrayConstPtr const & structureArray);
private:
StructureArrayConstPtr structureArray;
shared_vector value;
@@ -597,14 +597,14 @@ public:
* @param fieldName The name of the field to append.
* @param pvField The field to append.
*/
void appendPVField(String fieldName,PVFieldPtr & pvField);
void appendPVField(String fieldName,PVFieldPtr const & pvField);
/**
* Append fields to the structure.
* @param fieldNames The names of the fields to add.
* @param pvFields The fields to append.
* @return Pointer to the field or null if field does not exist.
*/
void appendPVFields(StringArray & fieldNames,PVFieldPtrArray & pvFields);
void appendPVFields(StringArray const & fieldNames,PVFieldPtrArray const & pvFields);
/**
* Remove a field from the structure.
* @param fieldName The name of the field to remove.
@@ -747,13 +747,13 @@ public:
* Constructor
* @param structure The introspection interface.
*/
PVStructure(StructureConstPtr & structure);
PVStructure(StructureConstPtr const & structure);
/**
* Constructor
* @param structure The introspection interface.
* @param pvFields The array of fields for the structure.
*/
PVStructure(StructureConstPtr structure,PVFieldPtrArray & pvFields);
PVStructure(StructureConstPtr const & structure,PVFieldPtrArray const & pvFields);
private:
PVFieldPtrArray pvFields;
StructureConstPtr structurePtr;
@@ -811,7 +811,7 @@ public:
virtual vector const & getVector() = 0;
virtual shared_vector const & getSharedVector() = 0;
protected:
PVValueArray(ScalarArrayConstPtr scalar)
PVValueArray(ScalarArrayConstPtr const & scalar)
: PVScalarArray(scalar) {}
friend class PVDataCreate;
};
@@ -880,67 +880,66 @@ public:
* @param field The introspection data to be used to create PVField.
* @return The PVField implementation.
*/
PVFieldPtr createPVField(FieldConstPtr & field);
PVFieldPtr createPVField(FieldConstPtr const & field);
/**
* Create a PVField using given a PVField to clone.
* This method calls the appropriate createPVScalar, createPVArray, or createPVStructure.
* @param fieldToClone The field to clone.
* @return The PVField implementation
*/
PVFieldPtr createPVField(PVFieldPtr & fieldToClone);
PVFieldPtr createPVField(PVFieldPtr const & fieldToClone);
/**
* Create an implementation of a scalar field reusing the Scalar introspection interface.
* @param scalar The introspection interface.
* @return The PVScalar implementation.
*/
PVScalarPtr createPVScalar(ScalarConstPtr & scalar);
PVScalarPtr createPVScalar(ScalarConstPtr const & scalar);
/**
* Create an implementation of a scalar field. A Scalar introspection interface is created.
* @param fieldType The field type.
* @return The PVScalar implementation.
*/
PVScalarPtr createPVScalar(ScalarType scalarType);
PVScalarPtr createPVScalar(ScalarType scalarType);
/**
* Create an implementation of a scalar field by cloning an existing PVScalar.
* The new PVScalar will have the same value and auxInfo as the original.
* @param scalarToClone The PVScalar to clone.
* @return The PVScalar implementation.
*/
PVScalarPtr createPVScalar(PVScalarPtr & scalarToClone);
PVScalarPtr createPVScalar(PVScalarPtr const & scalarToClone);
/**
* Create an implementation of an array field reusing the Array introspection interface.
* @param array The introspection interface.
* @return The PVScalarArray implementation.
*/
PVScalarArrayPtr createPVScalarArray(ScalarArrayConstPtr & scalarArray);
PVScalarArrayPtr createPVScalarArray(ScalarArrayConstPtr const & scalarArray);
/**
* Create an implementation for an array field. An Array introspection interface is created.
* @param parent The parent interface.
* @param elementType The element type.
* @return The PVScalarArray implementation.
*/
PVScalarArrayPtr createPVScalarArray(
ScalarType elementType);
PVScalarArrayPtr createPVScalarArray(ScalarType elementType);
/**
* Create an implementation of an array field by cloning an existing PVArray.
* The new PVArray will have the same value and auxInfo as the original.
* @param arrayToClone The PVScalarArray to clone.
* @return The PVScalarArray implementation.
*/
PVScalarArrayPtr createPVScalarArray(PVScalarArrayPtr & scalarArrayToClone);
PVScalarArrayPtr createPVScalarArray(PVScalarArrayPtr const & scalarArrayToClone);
/**
* Create an implementation of an array with structure elements.
* @param structureArray The introspection interface.
* All elements share the same introspection interface.
* @return The PVStructureArray implementation.
*/
PVStructureArrayPtr createPVStructureArray(StructureArrayConstPtr & structureArray);
PVStructureArrayPtr createPVStructureArray(StructureArrayConstPtr const & structureArray);
/**
* Create implementation for PVStructure.
* @param structure The introspection interface.
* @return The PVStructure implementation
*/
PVStructurePtr createPVStructure(StructureConstPtr & structure);
PVStructurePtr createPVStructure(StructureConstPtr const & structure);
/**
* Create implementation for PVStructure.
* @param fieldNames The field names.
@@ -948,13 +947,13 @@ public:
* @return The PVStructure implementation
*/
PVStructurePtr createPVStructure(
StringArray & fieldNames,PVFieldPtrArray & pvFields);
StringArray const & fieldNames,PVFieldPtrArray const & pvFields);
/**
* Create implementation for PVStructure.
* @param structToClone A structure. Each subfield and any auxInfo is cloned and added to the newly created structure.
* @return The PVStructure implementation.
*/
PVStructurePtr createPVStructure(PVStructurePtr & structToClone);
PVStructurePtr createPVStructure(PVStructurePtr const & structToClone);
private:
PVDataCreate();
};

10
pvDataApp/pv/pvIntrospect.h
View File

@@ -353,7 +353,7 @@ protected:
* Constructor.
* @param structure The introspection interface for the elements.
*/
StructureArray(StructureConstPtr structure);
StructureArray(StructureConstPtr const & structure);
/**
* Destructor.
*/
@@ -471,7 +471,7 @@ public:
* @param elementStructure The {@code Structure} for each array element.
* @return An {@code Array} Interface for the newly created object.
*/
StructureArrayConstPtr createStructureArray(StructureConstPtr structure) const;
StructureArrayConstPtr createStructureArray(StructureConstPtr const & structure) const;
/**
* Create a {@code Structure} field.
* @param fieldNames The array of {@code fieldNames} for the structure
@@ -489,8 +489,8 @@ public:
* @return a {@code Structure} interface for the newly created object.
*/
StructureConstPtr appendField(
StructureConstPtr structure,
String fieldName, FieldConstPtr field) const;
StructureConstPtr const & structure,
String fieldName, FieldConstPtr const & field) const;
/**
* Append fields to a structure.
* @param structure The structure to which the fields appended.
@@ -499,7 +499,7 @@ public:
* @return a {@code Structure} interface for the newly created object.
*/
StructureConstPtr appendFields(
StructureConstPtr structure,
StructureConstPtr const & structure,
StringArray const & fieldNames,
FieldConstPtrArray const & fields) const;
/**

2
pvDataApp/pv/standardField.h
View File

@@ -57,7 +57,7 @@ public:
~StandardField();
StructureConstPtr scalar(ScalarType type,String properties);
StructureConstPtr scalarArray(ScalarType elementType, String properties);
StructureConstPtr structureArray(StructureConstPtr & structure,String properties);
StructureConstPtr structureArray(StructureConstPtr const & structure,String properties);
StructureConstPtr enumerated();
StructureConstPtr enumerated(String properties);
StructureConstPtr alarm();

6
testApp/misc/Makefile
View File

@@ -26,9 +26,9 @@ PROD_HOST += testBaseException
testBaseException_SRCS += testBaseException.cpp
testBaseException_LIBS += pvData
#PROD_HOST += testSerialization
#testSerialization_SRCS += testSerialization.cpp
#testSerialization_LIBS += pvData Com
PROD_HOST += testSerialization
testSerialization_SRCS += testSerialization.cpp
testSerialization_LIBS += pvData Com
PROD_HOST += testTimeStamp
testTimeStamp_SRCS += testTimeStamp.cpp

472
testApp/misc/testSerialization.cpp
View File

@@ -23,6 +23,8 @@
#include <pv/CDRMonitor.h>
#include <pv/convert.h>
#include <pv/standardField.h>
#define BYTE_MAX_VALUE 127
#define BYTE_MIN_VALUE -128
#define SHORT_MAX_VALUE 32767
@@ -49,7 +51,7 @@ public:
virtual void flushSerializeBuffer() {
}
virtual void ensureBuffer(int size) {
virtual void ensureBuffer(size_t size) {
}
virtual void alignBuffer(int alignment) {
@@ -71,7 +73,7 @@ public:
class DeserializableControlImpl : public DeserializableControl,
public NoDefaultMethods {
public:
virtual void ensureData(int size) {
virtual void ensureData(size_t size) {
}
virtual void alignData(int alignment) {
@@ -90,8 +92,7 @@ public:
}
};
void serializationTest(PVField* field) {
void serializationTest(PVFieldPtr const & field) {
buffer->clear();
// serialize
@@ -100,33 +101,62 @@ void serializationTest(PVField* field) {
buffer->flip();
// create new instance and deserialize
PVField* deserializedField = getPVDataCreate()->createPVField(NULL,
field->getField());
PVFieldPtr deserializedField = getPVDataCreate()->createPVField(field->getField());
deserializedField->deserialize(buffer, control);
// must equal
bool isEqual = getConvert()->equals(*field,*deserializedField);
assert(isEqual);
delete deserializedField; // clean up
}
void testEquals(std::ostream& ofile) {
ofile<<"Testing equals...\n";
PVDataCreatePtr factory = getPVDataCreate();
assert(factory.get()!=NULL);
// be sure all is covered
for (int i = pvBoolean; i < pvString; i++)
{
ScalarType scalarType = static_cast<ScalarType>(i);
PVScalarPtr scalar1 = factory->createPVScalar(scalarType);
PVScalarPtr scalar2 = factory->createPVScalar(scalarType);
assert((*scalar1)==(*scalar2));
PVScalarArrayPtr array1 = factory->createPVScalarArray(scalarType);
PVScalarArrayPtr array2 = factory->createPVScalarArray(scalarType);
assert((*array1)==(*array2));
}
// and a structure
PVStructurePtr structure1 = factory->createPVStructure(getStandardField()->timeStamp());
PVStructurePtr structure2 = factory->createPVStructure(getStandardField()->timeStamp());
assert((*structure1)==(*structure2));
// and a structure array
PVStructureArrayPtr structureArray1 = factory->createPVStructureArray(getFieldCreate()->createStructureArray(structure1->getStructure()));
PVStructureArrayPtr structureArray2 = factory->createPVStructureArray(getFieldCreate()->createStructureArray(structure2->getStructure()));
assert((*structureArray1)==(*structureArray2));
ofile<<"!!! PASSED\n\n";
}
void testScalar(std::ostream& ofile) {
ofile<<"Testing scalars...\n";
PVDataCreate* factory = getPVDataCreate();
assert(factory!=NULL);
PVDataCreatePtr factory = getPVDataCreate();
assert(factory.get()!=NULL);
ofile<<"\tPVBoolean\n";
PVBoolean* pvBoolean = (PVBoolean*)factory->createPVScalar(NULL,
"pvBoolean", epics::pvData::pvBoolean);
PVBooleanPtr pvBoolean =
std::tr1::static_pointer_cast<PVBoolean>(factory->createPVScalar(epics::pvData::pvBoolean));
pvBoolean->put(false);
serializationTest(pvBoolean);
pvBoolean->put(true);
serializationTest(pvBoolean);
delete pvBoolean;
ofile<<"\tPVByte\n";
PVByte* pvByte = (PVByte*)factory->createPVScalar(NULL, "pvByte",
epics::pvData::pvByte);
PVBytePtr pvByte =
std::tr1::static_pointer_cast<PVByte>(factory->createPVScalar(epics::pvData::pvByte));
pvByte->put(0);
serializationTest(pvByte);
pvByte->put(12);
@@ -135,11 +165,10 @@ void testScalar(std::ostream& ofile) {
serializationTest(pvByte);
pvByte->put(BYTE_MIN_VALUE);
serializationTest(pvByte);
delete pvByte;
ofile<<"\tPVShort\n";
PVShort* pvShort = (PVShort*)factory->createPVScalar(NULL, "pvShort",
epics::pvData::pvShort);
PVShortPtr pvShort =
std::tr1::static_pointer_cast<PVShort>(factory->createPVScalar(epics::pvData::pvShort));
pvShort->put(0);
serializationTest(pvShort);
pvShort->put(123);
@@ -152,11 +181,10 @@ void testScalar(std::ostream& ofile) {
serializationTest(pvShort);
pvShort->put(SHORT_MIN_VALUE);
serializationTest(pvShort);
delete pvShort;
ofile<<"\tPVInt\n";
PVInt* pvInt = (PVInt*)factory->createPVScalar(NULL, "pvInt",
epics::pvData::pvInt);
PVIntPtr pvInt =
std::tr1::static_pointer_cast<PVInt>(factory->createPVScalar(epics::pvData::pvInt));
pvInt->put(0);
serializationTest(pvInt);
pvInt->put(123456);
@@ -173,11 +201,10 @@ void testScalar(std::ostream& ofile) {
serializationTest(pvInt);
pvInt->put(INT_MIN_VALUE);
serializationTest(pvInt);
delete pvInt;
ofile<<"\tPVLong\n";
PVLong* pvLong = (PVLong*)factory->createPVScalar(NULL, "pvLong",
epics::pvData::pvLong);
PVLongPtr pvLong =
std::tr1::static_pointer_cast<PVLong>(factory->createPVScalar(epics::pvData::pvLong));
pvLong->put(0);
serializationTest(pvLong);
pvLong->put(12345678901LL);
@@ -198,11 +225,10 @@ void testScalar(std::ostream& ofile) {
serializationTest(pvLong);
pvLong->put(LONG_MIN_VALUE);
serializationTest(pvLong);
delete pvLong;
ofile<<"\tPVFloat\n";
PVFloat* pvFloat = (PVFloat*)factory->createPVScalar(NULL, "pvFloat",
epics::pvData::pvFloat);
PVFloatPtr pvFloat =
std::tr1::static_pointer_cast<PVFloat>(factory->createPVScalar(epics::pvData::pvFloat));
pvFloat->put(0);
serializationTest(pvFloat);
pvFloat->put(12.345);
@@ -211,11 +237,10 @@ void testScalar(std::ostream& ofile) {
serializationTest(pvFloat);
pvFloat->put(FLOAT_MIN_VALUE);
serializationTest(pvFloat);
delete pvFloat;
ofile<<"\tPVDouble\n";
PVDouble* pvDouble = (PVDouble*)factory->createPVScalar(NULL, "pvDouble",
epics::pvData::pvDouble);
PVDoublePtr pvDouble =
std::tr1::static_pointer_cast<PVDouble>(factory->createPVScalar(epics::pvData::pvDouble));
pvDouble->put(0);
serializationTest(pvDouble);
pvDouble->put(12.345);
@@ -224,11 +249,10 @@ void testScalar(std::ostream& ofile) {
serializationTest(pvDouble);
pvDouble->put(DOUBLE_MIN_VALUE);
serializationTest(pvDouble);
delete pvDouble;
ofile<<"\tPVString\n";
PVString* pvString = (PVString*)factory->createPVScalar(NULL, "pvString",
epics::pvData::pvString);
PVStringPtr pvString =
std::tr1::static_pointer_cast<PVString>(factory->createPVScalar(epics::pvData::pvString));
pvString->put("");
serializationTest(pvString);
pvString->put("s");
@@ -244,7 +268,7 @@ void testScalar(std::ostream& ofile) {
pvString->put(String(10000, 'a'));
serializationTest(pvString);
delete pvString;
// TODO unsigned test
ofile<<"!!! PASSED\n\n";
}
@@ -252,93 +276,86 @@ void testScalar(std::ostream& ofile) {
void testArray(std::ostream& ofile) {
ofile<<"Testing arrays...\n";
PVDataCreate* factory = getPVDataCreate();
assert(factory!=NULL);
PVDataCreatePtr factory = getPVDataCreate();
assert(factory.get()!=NULL);
ofile<<"\tPVBooleanArray\n";
bool boolEmpty[] = { false };
bool bv[] = { false, true, false, true, true };
PVBooleanArray* pvBoolean = (PVBooleanArray*)factory->createPVScalarArray(
NULL, "pvBooleanArray", epics::pvData::pvBoolean);
pvBoolean->put(0, 0, boolEmpty, 0);
PVBooleanArrayPtr pvBoolean =
std::tr1::static_pointer_cast<PVBooleanArray>(factory->createPVScalarArray(epics::pvData::pvBoolean));
//TODO pvBoolean->put(0, 0, boolEmpty, 0);
serializationTest(pvBoolean);
pvBoolean->put(0, 5, bv, 0);
//TODO pvBoolean->put(0, 5, bv, 0);
serializationTest(pvBoolean);
delete pvBoolean;
ofile<<"\tPVByteArray\n";
int8 byteEmpty[] = { 0 };
int8 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);
PVByteArrayPtr pvByte =
std::tr1::static_pointer_cast<PVByteArray>(factory->createPVScalarArray(epics::pvData::pvByte));
pvByte->put(0, 0, byteEmpty, 0);
serializationTest(pvByte);
pvByte->put(0, 8, byv, 0);
serializationTest(pvByte);
delete pvByte;
ofile<<"\tPVShortArray\n";
int16 shortEmpty[] = { 0 };
int16 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);
PVShortArrayPtr pvShort =
std::tr1::static_pointer_cast<PVShortArray>(factory->createPVScalarArray(epics::pvData::pvShort));
pvShort->put(0, 0, shortEmpty, 0);
serializationTest(pvShort);
pvShort->put(0, 8, sv, 0);
serializationTest(pvShort);
delete pvShort;
ofile<<"\tPVIntArray\n";
int32 intEmpty[] = { 0 };
int32 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);
PVIntArrayPtr pvInt =
std::tr1::static_pointer_cast<PVIntArray>(factory->createPVScalarArray(epics::pvData::pvInt));
pvInt->put(0, 0, intEmpty, 0);
serializationTest(pvInt);
pvInt->put(0, 8, iv, 0);
serializationTest(pvInt);
delete pvInt;
ofile<<"\tPVLongArray\n";
int64 longEmpty[] = { 0 };
int64 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);
PVLongArrayPtr pvLong =
std::tr1::static_pointer_cast<PVLongArray>(factory->createPVScalarArray(epics::pvData::pvLong));
pvLong->put(0, 0, longEmpty, 0);
serializationTest(pvLong);
pvLong->put(0, 8, lv, 0);
serializationTest(pvLong);
delete pvLong;
ofile<<"\tPVFloatArray\n";
float floatEmpty[] = { (float)0.0 };
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);
PVFloatArrayPtr pvFloat =
std::tr1::static_pointer_cast<PVFloatArray>(factory->createPVScalarArray(epics::pvData::pvFloat));
pvFloat->put(0, 0, floatEmpty, 0);
serializationTest(pvFloat);
pvFloat->put(0, 8, fv, 0);
serializationTest(pvFloat);
delete pvFloat;
ofile<<"\tPVDoubleArray\n";
double doubleEmpty[] = { (double)0.0 };
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);
PVDoubleArrayPtr pvDouble =
std::tr1::static_pointer_cast<PVDoubleArray>(factory->createPVScalarArray(epics::pvData::pvDouble));
pvDouble->put(0, 0, doubleEmpty, 0);
serializationTest(pvDouble);
pvDouble->put(0, 8, dv, 0);
serializationTest(pvDouble);
delete pvDouble;
ofile<<"\tPVStringArray\n";
String stringEmpty[] = { "" };
@@ -353,295 +370,122 @@ void testArray(std::ostream& ofile) {
"smile",
"this is a little longer string... maybe a little but longer... this makes test better",
String(10000, 'b') };
PVStringArray* pvString = (PVStringArray*)factory->createPVScalarArray(
NULL, "pvStringArray", epics::pvData::pvString);
PVStringArrayPtr pvString =
std::tr1::static_pointer_cast<PVStringArray>(factory->createPVScalarArray(epics::pvData::pvString));
pvString->put(0, 0, stringEmpty, 0);
serializationTest(pvString);
pvString->put(0, 8, strv, 0);
serializationTest(pvString);
delete pvString;
ofile<<"!!! PASSED\n\n";
}
void testScalarEquals(std::ostream& ofile) {
ofile<<"Testing scalar equals...\n";
PVDataCreate* factory = getPVDataCreate();
assert(factory!=NULL);
void testNonInitialized(std::ostream& ofile) {
ofile<<"Testing non-initialized...\n";
PVDataCreatePtr factory = getPVDataCreate();
assert(factory.get()!=NULL);
PVScalar *scalar1, *scalar2;
// be sure all is covered
for (int i = pvBoolean; i < pvString; i++)
{
ScalarType scalarType = static_cast<ScalarType>(i);
scalar1 = factory->createPVScalar(NULL, "pvBoolean",
epics::pvData::pvBoolean);
scalar2 = factory->createPVScalar(NULL, "pvBoolean",
epics::pvData::pvBoolean);
assert((*scalar1)==(*scalar2));
delete scalar1;
delete scalar2;
PVScalarPtr scalar = factory->createPVScalar(scalarType);
serializationTest(scalar);
scalar1 = factory->createPVScalar(NULL, "pvByte", epics::pvData::pvByte);
scalar2 = factory->createPVScalar(NULL, "pvByte", epics::pvData::pvByte);
assert((*scalar1)==(*scalar2));
delete scalar1;
delete scalar2;
PVScalarArrayPtr array = factory->createPVScalarArray(scalarType);
serializationTest(array);
}
scalar1 = factory->createPVScalar(NULL, "pvShort", epics::pvData::pvShort);
scalar2 = factory->createPVScalar(NULL, "pvShort", epics::pvData::pvShort);
assert((*scalar1)==(*scalar2));
delete scalar1;
delete scalar2;
// and a structure
PVStructurePtr structure = factory->createPVStructure(getStandardField()->timeStamp());
serializationTest(structure);
scalar1 = factory->createPVScalar(NULL, "pvInt", epics::pvData::pvInt);
scalar2 = factory->createPVScalar(NULL, "pvInt", epics::pvData::pvInt);
assert((*scalar1)==(*scalar2));
delete scalar1;
delete scalar2;
// and a structure array
PVStructureArrayPtr structureArray = factory->createPVStructureArray(getFieldCreate()->createStructureArray(structure->getStructure()));
serializationTest(structureArray);
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();
FieldConstPtrArray fields = new FieldConstPtr[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
ofile<<"!!! PASSED\n\n";
}
void testScalarNonInitialized(std::ostream& ofile) {
ofile<<"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();
FieldConstPtrArray fields = new FieldConstPtr[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
ofile<<"!!! PASSED\n\n";
}
void testArrayNonInitialized(std::ostream& ofile) {
ofile<<"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();
FieldConstPtrArray fields = new FieldConstPtr[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'
ofile<<"!!! PASSED\n\n";
ofile<<"!!! PASSED\n\n";
}
void testStructure(std::ostream& ofile) {
ofile<<"Testing structure...\n";
FieldCreate* fieldCreate = getFieldCreate();
PVDataCreate* pvDataCreate = getPVDataCreate();
assert(fieldCreate!=NULL);
assert(pvDataCreate!=NULL);
PVDataCreatePtr factory = getPVDataCreate();
assert(factory.get()!=NULL);
ofile<<"\tSimple structure serialization\n";
FieldConstPtrArray fields = new FieldConstPtr[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);
PVStructurePtr pvStructure = factory->createPVStructure(getStandardField()->timeStamp());
pvStructure->getLongField("secondsPastEpoch")->put(123);
pvStructure->getIntField("nanoSeconds")->put(456);
pvStructure->getIntField("userTag")->put(789);
serializationTest(pvStructure);
//serializationTest(pvStructure->getStructure());
delete pvStructure;
ofile<<"\tComplex structure serialization\n";
// and more complex :)
FieldConstPtrArray fields2 = new FieldConstPtr[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);
FieldConstPtrArray fields3 = new FieldConstPtr[2];
fields3[0] = fieldCreate->createScalar("secondsSinceEpoch", epics::pvData::pvLong);
fields3[1] = fieldCreate->createScalar("nanoSeconds", epics::pvData::pvInt);
fields2[3] = fieldCreate->createStructure("timeStamp", 2, fields3);
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(fields3[0]->getFieldName())->put(789);
ps->getIntField(fields3[1]->getFieldName())->put(1011);
serializationTest(pvStructure2);
//serializationTest(pvStructure2->getStructure());
delete pvStructure2;
pvStructure = factory->createPVStructure(
getStandardField()->structureArray(
getStandardField()->timeStamp(), "alarm,control,display,timeStamp")
);
// TODO fill with data
serializationTest(pvStructure);
ofile<<"!!! PASSED\n\n";
}
/*
void testIntrospectionSerialization() {
cout<<"Testing introspection serialization...\n";
FieldCreate* factory = getFieldCreate();
assert(factory!=NULL);
void serializatioTest(FieldConstPtr const & field)
{
buffer->clear();
ScalarConstPtr scalar = factory->createScalar("scalar", epics::pvData::pvDouble);
serializatioTest(scalar);
delete scalar;
// serialize
field->serialize(buffer, flusher);
ScalarArrayConstPtr array = factory->createScalarArray("array", epics::pvData::pvDouble);
serializatioTest(array);
delete array;
// deserialize
buffer->flip();
cout<<"!!! PASSED\n\n";
FieldConstPtr deserializedField = getFieldCreate()->deserialize(buffer, control);
// must equal
bool isEqual = *field == *deserializedField;
assert(isEqual);
//assertEquals("field " + field.toString() + " serialization broken", field, deserializedField);
}
void testIntrospectionSerialization(std::ostream& ofile)
{
ofile<<"Testing introspection serialization...\n";
FieldCreatePtr factory = getFieldCreate();
assert(factory.get()!=NULL);
// be sure all is covered
for (int i = pvBoolean; i < pvString; i++)
{
ScalarType scalarType = static_cast<ScalarType>(i);
ScalarConstPtr scalar = factory->createScalar(scalarType);
serializatioTest(scalar);
ScalarArrayConstPtr array = factory->createScalarArray(scalarType);
serializatioTest(array);
}
// and a structure
StructureConstPtr structure = getStandardField()->timeStamp();
serializatioTest(structure);
// and a structure array
StructureArrayConstPtr structureArray = factory->createStructureArray(structure);
serializatioTest(structureArray);
ofile<<"!!! PASSED\n\n";
}
*/
void testStringCopy(std::ostream& ofile) {
String s1 = "abc";
String s2 = s1;
if (s1.c_str() != s2.c_str())
ofile << "\n!!! implementation of epics::pvData::String assigment operator does not share content !!!\n\n";
ofile << "\n!!! implementation of epics::pvData::String assignment operator does not share content !!!\n\n";
}
int main(int argc, char *argv[]) {
@@ -661,13 +505,15 @@ int main(int argc, char *argv[]) {
buffer = new ByteBuffer(1<<16);
testStringCopy(*out);
testScalarEquals(*out);
testIntrospectionSerialization(*out);
testEquals(*out);
testNonInitialized(*out);
testScalar(*out);
testArray(*out);
testScalarNonInitialized(*out);
testArrayNonInitialized(*out);
testStructure(*out);
//testIntrospectionSerialization();
delete buffer;
delete control;