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
pvDataApp/factory/Compare.cpp
+5 -2
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 {
pvDataApp/factory/Convert.cpp
+64 -64
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);
pvDataApp/factory/FieldCreateFactory.cpp
+6 -6
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
{
pvDataApp/factory/PVArray.cpp
+1 -1
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())
{ }
pvDataApp/factory/PVDataCreateFactory.cpp
+16 -16
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) {
pvDataApp/factory/PVScalar.cpp
+1 -1
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()
pvDataApp/factory/PVScalarArray.cpp
+1 -1
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()
pvDataApp/factory/PVStructure.cpp
+5 -5
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();
pvDataApp/factory/PVStructureArray.cpp
+1 -1
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> >
pvDataApp/factory/StandardField.cpp
+1 -1
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);
pvDataApp/pv/convert.h
+62 -62
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.
pvDataApp/pv/pvData.h
+23 -24
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();
};
pvDataApp/pv/pvIntrospect.h
+5 -5
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;
/**
pvDataApp/pv/standardField.h
+1 -1
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();