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

replace copyScalarArray with PVScalarArray::assign

Browse Source
This commit is contained in:
Michael Davidsaver
2013-04-30 13:53:55 -04:00
parent e948af1851
commit a6bfab2d74
5 changed files with 34 additions and 228 deletions
Download Patch File Download Diff File Expand all files Collapse all files

195
pvDataApp/factory/Convert.cpp
View File

@@ -546,8 +546,7 @@ void Convert::copy(PVFieldPtr const & from, PVFieldPtr const & to)
{
PVScalarArrayPtr fromArray = static_pointer_cast<PVScalarArray>(from);
PVScalarArrayPtr toArray = static_pointer_cast<PVScalarArray>(to);
size_t length = copyScalarArray(fromArray,0,toArray,0,fromArray->getLength());
if(toArray->getLength()!=length) toArray->setLength(length);
toArray->assign(*fromArray.get());
return;
}
case structure:
@@ -586,98 +585,7 @@ void Convert::copyScalar(PVScalarPtr const & from, PVScalarPtr const & to)
String message("Convert.copyScalar destination is immutable");
throw std::invalid_argument(message);
}
ScalarType fromType = from->getScalar()->getScalarType();
ScalarType toType = to->getScalar()->getScalarType();
switch(fromType) {
case pvBoolean: {
if(toType!=pvBoolean) {
if(toType!=pvString) {
String message("Convert.copyScalar arguments are not compatible");
throw std::invalid_argument(message);
}
}
PVBooleanPtr data = static_pointer_cast<PVBoolean>(from);
if(toType==pvString) {
PVStringPtr dataTo = static_pointer_cast<PVString>(to);
String buf("");
data->toString(&buf);
dataTo->put(buf);
} else {
bool value = data->get();
PVBooleanPtr dataTo = static_pointer_cast<PVBoolean>(to);
dataTo->put(value);
}
return;
}
case pvByte : {
PVBytePtr data = static_pointer_cast<PVByte>(from);
int8 value = data->get();
fromByte(to,value);
return;
}
case pvShort : {
PVShortPtr data = static_pointer_cast<PVShort>(from);
int16 value = data->get();
fromShort(to,value);
return;
}
case pvInt :{
PVIntPtr data = static_pointer_cast<PVInt>(from);
int32 value = data->get();
fromInt(to,value);
return;
}
case pvLong : {
PVLongPtr data = static_pointer_cast<PVLong>(from);
int64 value = data->get();
fromLong(to,value);
return;
}
case pvUByte : {
PVUBytePtr data = static_pointer_cast<PVUByte>(from);
uint8 value = data->get();
fromUByte(to,value);
return;
}
case pvUShort : {
PVUShortPtr data = static_pointer_cast<PVUShort>(from);
uint16 value = data->get();
fromUShort(to,value);
return;
}
case pvUInt :{
PVUIntPtr data = static_pointer_cast<PVUInt>(from);
uint32 value = data->get();
fromUInt(to,value);
return;
}
case pvULong : {
PVULongPtr data = static_pointer_cast<PVULong>(from);
uint64 value = data->get();
fromULong(to,value);
return;
}
case pvFloat : {
PVFloatPtr data = static_pointer_cast<PVFloat>(from);
float value = data->get();
fromFloat(to,value);
return;
}
case pvDouble : {
PVDoublePtr data = static_pointer_cast<PVDouble>(from);
double value = data->get();
fromDouble(to,value);
return;
}
case pvString: {
PVStringPtr data = static_pointer_cast<PVString>(from);
String value = data->get();
fromString(to,value);
return;
}
}
String message("Convert::copyScalar should never get here");
throw std::logic_error(message);
to->assign(*from.get());
}
bool Convert::isCopyScalarArrayCompatible(ScalarArrayConstPtr const &fromArray,
@@ -693,99 +601,6 @@ bool Convert::isCopyScalarArrayCompatible(ScalarArrayConstPtr const &fromArray,
return false;
}
size_t Convert::copyScalarArray(PVScalarArrayPtr const & from, size_t offset,
PVScalarArrayPtr const & to, size_t toOffset, size_t length)
{
if(to->isImmutable()) {
if(from==to) return from->getLength();
String message("Convert.copyArray destination is immutable");
throw std::invalid_argument(message);
}
ScalarType fromElementType = from->getScalarArray()->getElementType();
ScalarType toElementType = to->getScalarArray()->getElementType();
if(from->isImmutable() && (fromElementType==toElementType)) {
if(offset==0 && toOffset==0 && length==from->getLength()) {
return copyArrayDataReference(from.get(),to.get());
}
}
size_t ncopy = 0;
if(ScalarTypeFunc::isNumeric(fromElementType)
&& ScalarTypeFunc::isNumeric(toElementType)) {
return copyNumericArray(from.get(),offset,to.get(),toOffset,length);
} else if(toElementType==pvBoolean && fromElementType==pvBoolean) {
PVBooleanArray *pvfrom = static_cast<PVBooleanArray*>(from.get());
PVBooleanArray *pvto = static_cast<PVBooleanArray*>(to.get());
while(length>0) {
size_t num = 0;
size_t fromOffset = 0;
BooleanArrayData booleanArrayData;
num = pvfrom->get(offset,length,booleanArrayData);
boolean * data = pvfrom->get();
fromOffset = booleanArrayData.offset;
if(num<=0) return ncopy;
while(num>0) {
size_t n = pvto->put(toOffset,num,data,fromOffset);
if(n<=0) return ncopy;
length -= n; num -= n; ncopy+=n; offset += n; toOffset += n;
}
}
return ncopy;
} else if(toElementType==pvString && fromElementType==pvString) {
PVStringArray *pvfrom = static_cast<PVStringArray*>(from.get());
PVStringArray *pvto = static_cast<PVStringArray*>(to.get());
while(length>0) {
size_t num = 0;
String *data;
size_t fromOffset = 0;
StringArrayData stringArrayData;
num = pvfrom->get(offset,length,stringArrayData);
data = pvfrom->get();
fromOffset = stringArrayData.offset;
if(num<=0) return ncopy;
while(num>0) {
size_t n = pvto->put(toOffset,num,data,fromOffset);
if(n<=0) return ncopy;
length -= n; num -= n; ncopy+=n; offset += n; toOffset += n;
}
}
return ncopy;
} else if(toElementType==pvString) {
PVStringArray *pvto = static_cast<PVStringArray*>(to.get());
ncopy = from->getLength();
if(ncopy>length) ncopy = length;
size_t num = ncopy;
StringArray toData(1);
while(num>0) {
toStringArray(from,offset,1,toData,0);
if(pvto->put(toOffset,1,&toData[0],0)<=0) break;
num--; offset++; toOffset++;
}
return ncopy;
} else if(fromElementType==pvString) {
PVStringArray *pvfrom = static_cast<PVStringArray*>(from.get());
while(length>0) {
size_t num = 0;
size_t fromOffset = 0;
StringArrayData stringArrayData;
num = pvfrom->get(offset,length,stringArrayData);
StringArray const & data = stringArrayData.data;
fromOffset = stringArrayData.offset;
if(num<=0) return ncopy;
while(num>0) {
size_t n = fromStringArray(to,toOffset,num,data,fromOffset);
if(n<=0) return ncopy;
length -= n; num -= n; ncopy+=n; offset += n; toOffset += n;
}
}
return ncopy;
}
String message("Convert::copyScalarArray should not get here");
throw std::logic_error(message);
}
bool Convert::isCopyStructureCompatible(
StructureConstPtr const &fromStruct, StructureConstPtr const &toStruct)
{
@@ -865,7 +680,7 @@ void Convert::copyStructure(PVStructurePtr const & from, PVStructurePtr const &
&& (pvArray->getScalarArray()->getElementType()==pvString)) {
PVScalarArrayPtr toArray =
static_pointer_cast<PVScalarArray>(toDatas[1]);
copyScalarArray(pvArray,0,toArray,0,pvArray->getLength());
toArray->assign(*pvArray.get());
PVScalarPtr toScalar = static_pointer_cast<PVScalar>(toDatas[0]);
copyScalar(pvScalar,toScalar);
return;
@@ -894,9 +709,7 @@ void Convert::copyStructure(PVStructurePtr const & from, PVStructurePtr const &
{
PVScalarArrayPtr fromArray = static_pointer_cast<PVScalarArray>(fromData);
PVScalarArrayPtr toArray = static_pointer_cast<PVScalarArray>(toData);
size_t length = copyScalarArray(
fromArray,0,toArray,0,fromArray->getLength());
if(toArray->getLength()!=length) toArray->setLength(length);
toArray->assign(*fromArray.get());
break;
}
case structure:

2
pvDataApp/factory/PVDataCreateFactory.cpp
View File

@@ -672,7 +672,7 @@ PVScalarArrayPtr PVDataCreate::createPVScalarArray(
{
PVScalarArrayPtr pvArray = createPVScalarArray(
arrayToClone->getScalarArray()->getElementType());
getConvert()->copyScalarArray(arrayToClone,0, pvArray,0,arrayToClone->getLength());
pvArray->assign(*arrayToClone.get());
PVAuxInfoPtr from = arrayToClone->getPVAuxInfo();
PVAuxInfoPtr to = pvArray->getPVAuxInfo();
PVAuxInfo::PVInfoMap & map = from->getInfoMap();

16
pvDataApp/pv/convert.h
View File

@@ -254,22 +254,6 @@ public:
bool isCopyScalarArrayCompatible(
ScalarArrayConstPtr const & from,
ScalarArrayConstPtr const & to);
/**
* Convert from a source PV array to a destination PV array.
* @param from The source array.
* @param offset Starting element in the source.
* @param to The destination array.
* @param toOffset Starting element in the array.
* @param length Number of elements to transfer.
* @return Number of elements converted.
* @throws std::invalid_argument if the arguments are not compatible.
*/
std::size_t copyScalarArray(
PVScalarArrayPtr const & from,
std::size_t offset,
PVScalarArrayPtr const & to,
std::size_t toOffset,
std::size_t length);
/**
* Are from and to valid arguments for copyStructure.
* They are only compatible if they have the same Structure description.

17
pvDataApp/pv/pvData.h
View File

@@ -670,7 +670,7 @@ public:
}
virtual void putFrom(ScalarType, const void*, size_t ,size_t) = 0;
virtual void assign(const PVScalarArray& pv) = 0;
virtual void assign(PVScalarArray& pv) = 0;
protected:
PVScalarArray(ScalarArrayConstPtr const & scalarArray);
@@ -1098,10 +1098,19 @@ public:
castUnsafeV(count, typeCode, (void*)(get()+offset), dtype, ptr);
}
virtual void assign(const PVScalarArray& pv)
virtual void assign(PVScalarArray& pv)
{
setLength(pv.getLength());
pv.getAs(typeCode, (void*)get(), std::min(getLength(),pv.getLength()), 0);
if(this==&pv)
return;
if(isImmutable())
throw std::invalid_argument("Destination is immutable");
if(pv.isImmutable() && typeCode==pv.getScalarArray()->getElementType()) {
PVValueArray& pvr = static_cast<PVValueArray&>(pv);
shareData(pvr.getSharedVector(), pvr.getCapacity(), pvr.getLength());
} else {
setLength(pv.getLength());
pv.getAs(typeCode, (void*)get(), std::min(getLength(),pv.getLength()), 0);
}
}
protected:

32
testApp/pv/testConvert.cpp
View File

@@ -441,10 +441,10 @@ static void testConvertScalarArray(FILE *fd) {
convert->fromByteArray(pvDoublePtr,0,length,barray,0);
builder.clear(); pvDoublePtr->toString(&builder);
if(debug) fprintf(fd,"double %s\n",builder.c_str());
convert->copyScalarArray(pvUBytePtr,0, pvFloatPtr,0,length);
pvUBytePtr->assign(*pvFloatPtr.get());
builder.clear(); pvFloatPtr->toString(&builder);
if(debug) fprintf(fd,"float from unsigned %s\n",builder.c_str());
convert->copyScalarArray(pvUBytePtr,0, pvDoublePtr,0,length);
pvUBytePtr->assign(*pvDoublePtr.get());
builder.clear(); pvDoublePtr->toString(&builder);
if(debug) fprintf(fd,"double from unsigned %s\n",builder.c_str());
fprintf(fd,"fromByte PASSED\n");
@@ -484,10 +484,10 @@ static void testConvertScalarArray(FILE *fd) {
convert->fromShortArray(pvDoublePtr,0,length,sarray,0);
builder.clear(); pvDoublePtr->toString(&builder);
if(debug) fprintf(fd,"double %s\n",builder.c_str());
convert->copyScalarArray(pvUShortPtr,0, pvFloatPtr,0,length);
pvUShortPtr->assign(*pvFloatPtr.get());
builder.clear(); pvFloatPtr->toString(&builder);
if(debug) fprintf(fd,"float from unsigned %s\n",builder.c_str());
convert->copyScalarArray(pvUShortPtr,0, pvDoublePtr,0,length);
pvUShortPtr->assign(*pvDoublePtr.get());
builder.clear(); pvDoublePtr->toString(&builder);
if(debug) fprintf(fd,"double from unsigned %s\n",builder.c_str());
fprintf(fd,"fromShort PASSED\n");
@@ -527,10 +527,10 @@ static void testConvertScalarArray(FILE *fd) {
convert->fromIntArray(pvDoublePtr,0,length,iarray,0);
builder.clear(); pvDoublePtr->toString(&builder);
if(debug) fprintf(fd,"double %s\n",builder.c_str());
convert->copyScalarArray(pvUIntPtr,0, pvFloatPtr,0,length);
pvUIntPtr->assign(*pvFloatPtr.get());
builder.clear(); pvFloatPtr->toString(&builder);
if(debug) fprintf(fd,"float from unsigned %s\n",builder.c_str());
convert->copyScalarArray(pvUIntPtr,0, pvDoublePtr,0,length);
pvUIntPtr->assign(*pvDoublePtr.get());
builder.clear(); pvDoublePtr->toString(&builder);
if(debug) fprintf(fd,"double from unsigned %s\n",builder.c_str());
fprintf(fd,"fromInt PASSED\n");
@@ -570,10 +570,10 @@ static void testConvertScalarArray(FILE *fd) {
convert->fromLongArray(pvDoublePtr,0,length,larray,0);
builder.clear(); pvDoublePtr->toString(&builder);
if(debug) fprintf(fd,"double %s\n",builder.c_str());
convert->copyScalarArray(pvULongPtr,0, pvFloatPtr,0,length);
pvULongPtr->assign(*pvFloatPtr.get());
builder.clear(); pvFloatPtr->toString(&builder);
if(debug) fprintf(fd,"float from unsigned %s\n",builder.c_str());
convert->copyScalarArray(pvULongPtr,0, pvDoublePtr,0,length);
pvULongPtr->assign(*pvDoublePtr.get());
builder.clear(); pvDoublePtr->toString(&builder);
if(debug) fprintf(fd,"double from unsigned %s\n",builder.c_str());
fprintf(fd,"fromLong PASSED\n");
@@ -613,10 +613,10 @@ static void testConvertScalarArray(FILE *fd) {
convert->fromUByteArray(pvDoublePtr,0,length,ubarray,0);
builder.clear(); pvDoublePtr->toString(&builder);
if(debug) fprintf(fd,"double %s\n",builder.c_str());
convert->copyScalarArray(pvUBytePtr,0, pvFloatPtr,0,length);
pvUBytePtr->assign(*pvFloatPtr.get());
builder.clear(); pvFloatPtr->toString(&builder);
if(debug) fprintf(fd,"float from unsigned %s\n",builder.c_str());
convert->copyScalarArray(pvUBytePtr,0, pvDoublePtr,0,length);
pvUBytePtr->assign(*pvDoublePtr.get());
builder.clear(); pvDoublePtr->toString(&builder);
if(debug) fprintf(fd,"double from unsigned %s\n",builder.c_str());
fprintf(fd,"fromUByte PASSED\n");
@@ -656,10 +656,10 @@ static void testConvertScalarArray(FILE *fd) {
convert->fromUShortArray(pvDoublePtr,0,length,usarray,0);
builder.clear(); pvDoublePtr->toString(&builder);
if(debug) fprintf(fd,"double %s\n",builder.c_str());
convert->copyScalarArray(pvUShortPtr,0, pvFloatPtr,0,length);
pvUShortPtr->assign(*pvFloatPtr.get());
builder.clear(); pvFloatPtr->toString(&builder);
if(debug) fprintf(fd,"float from unsigned %s\n",builder.c_str());
convert->copyScalarArray(pvUShortPtr,0, pvDoublePtr,0,length);
pvUShortPtr->assign(*pvDoublePtr.get());
builder.clear(); pvDoublePtr->toString(&builder);
if(debug) fprintf(fd,"double from unsigned %s\n",builder.c_str());
fprintf(fd,"fromUShort PASSED\n");
@@ -699,10 +699,10 @@ static void testConvertScalarArray(FILE *fd) {
convert->fromUIntArray(pvDoublePtr,0,length,uiarray,0);
builder.clear(); pvDoublePtr->toString(&builder);
if(debug) fprintf(fd,"double %s\n",builder.c_str());
convert->copyScalarArray(pvUIntPtr,0, pvFloatPtr,0,length);
pvUIntPtr->assign(*pvFloatPtr.get());
builder.clear(); pvFloatPtr->toString(&builder);
if(debug) fprintf(fd,"float from unsigned %s\n",builder.c_str());
convert->copyScalarArray(pvUIntPtr,0, pvDoublePtr,0,length);
pvUIntPtr->assign(*pvDoublePtr.get());
builder.clear(); pvDoublePtr->toString(&builder);
if(debug) fprintf(fd,"double from unsigned %s\n",builder.c_str());
fprintf(fd,"fromUInt PASSED\n");
@@ -742,10 +742,10 @@ static void testConvertScalarArray(FILE *fd) {
convert->fromULongArray(pvDoublePtr,0,length,ularray,0);
builder.clear(); pvDoublePtr->toString(&builder);
if(debug) fprintf(fd,"double %s\n",builder.c_str());
convert->copyScalarArray(pvULongPtr,0, pvFloatPtr,0,length);
pvULongPtr->assign(*pvFloatPtr.get());
builder.clear(); pvFloatPtr->toString(&builder);
if(debug) fprintf(fd,"float from unsigned %s\n",builder.c_str());
convert->copyScalarArray(pvULongPtr,0, pvDoublePtr,0,length);
pvULongPtr->assign(*pvDoublePtr.get());
builder.clear(); pvDoublePtr->toString(&builder);
if(debug) fprintf(fd,"double from unsigned %s\n",builder.c_str());
fprintf(fd,"fromLong PASSED\n");