From a6bfab2d7494f82adafe5bc8a2bfc703f6f9017c Mon Sep 17 00:00:00 2001 From: Michael Davidsaver Date: Tue, 30 Apr 2013 13:53:55 -0400 Subject: [PATCH] replace copyScalarArray with PVScalarArray::assign --- pvDataApp/factory/Convert.cpp | 195 +--------------------- pvDataApp/factory/PVDataCreateFactory.cpp | 2 +- pvDataApp/pv/convert.h | 16 -- pvDataApp/pv/pvData.h | 17 +- testApp/pv/testConvert.cpp | 32 ++-- 5 files changed, 34 insertions(+), 228 deletions(-) diff --git a/pvDataApp/factory/Convert.cpp b/pvDataApp/factory/Convert.cpp index 0d8dc07..ced8c69 100644 --- a/pvDataApp/factory/Convert.cpp +++ b/pvDataApp/factory/Convert.cpp @@ -546,8 +546,7 @@ void Convert::copy(PVFieldPtr const & from, PVFieldPtr const & to) { PVScalarArrayPtr fromArray = static_pointer_cast(from); PVScalarArrayPtr toArray = static_pointer_cast(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(from); - if(toType==pvString) { - PVStringPtr dataTo = static_pointer_cast(to); - String buf(""); - data->toString(&buf); - dataTo->put(buf); - } else { - bool value = data->get(); - PVBooleanPtr dataTo = static_pointer_cast(to); - dataTo->put(value); - } - return; - } - case pvByte : { - PVBytePtr data = static_pointer_cast(from); - int8 value = data->get(); - fromByte(to,value); - return; - } - case pvShort : { - PVShortPtr data = static_pointer_cast(from); - int16 value = data->get(); - fromShort(to,value); - return; - } - case pvInt :{ - PVIntPtr data = static_pointer_cast(from); - int32 value = data->get(); - fromInt(to,value); - return; - } - case pvLong : { - PVLongPtr data = static_pointer_cast(from); - int64 value = data->get(); - fromLong(to,value); - return; - } - case pvUByte : { - PVUBytePtr data = static_pointer_cast(from); - uint8 value = data->get(); - fromUByte(to,value); - return; - } - case pvUShort : { - PVUShortPtr data = static_pointer_cast(from); - uint16 value = data->get(); - fromUShort(to,value); - return; - } - case pvUInt :{ - PVUIntPtr data = static_pointer_cast(from); - uint32 value = data->get(); - fromUInt(to,value); - return; - } - case pvULong : { - PVULongPtr data = static_pointer_cast(from); - uint64 value = data->get(); - fromULong(to,value); - return; - } - case pvFloat : { - PVFloatPtr data = static_pointer_cast(from); - float value = data->get(); - fromFloat(to,value); - return; - } - case pvDouble : { - PVDoublePtr data = static_pointer_cast(from); - double value = data->get(); - fromDouble(to,value); - return; - } - case pvString: { - PVStringPtr data = static_pointer_cast(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(from.get()); - PVBooleanArray *pvto = static_cast(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(from.get()); - PVStringArray *pvto = static_cast(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(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(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(toDatas[1]); - copyScalarArray(pvArray,0,toArray,0,pvArray->getLength()); + toArray->assign(*pvArray.get()); PVScalarPtr toScalar = static_pointer_cast(toDatas[0]); copyScalar(pvScalar,toScalar); return; @@ -894,9 +709,7 @@ void Convert::copyStructure(PVStructurePtr const & from, PVStructurePtr const & { PVScalarArrayPtr fromArray = static_pointer_cast(fromData); PVScalarArrayPtr toArray = static_pointer_cast(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: diff --git a/pvDataApp/factory/PVDataCreateFactory.cpp b/pvDataApp/factory/PVDataCreateFactory.cpp index b32d493..7561336 100644 --- a/pvDataApp/factory/PVDataCreateFactory.cpp +++ b/pvDataApp/factory/PVDataCreateFactory.cpp @@ -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(); diff --git a/pvDataApp/pv/convert.h b/pvDataApp/pv/convert.h index a54c258..b06c6b8 100644 --- a/pvDataApp/pv/convert.h +++ b/pvDataApp/pv/convert.h @@ -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. diff --git a/pvDataApp/pv/pvData.h b/pvDataApp/pv/pvData.h index b7e3e0d..3ef001c 100644 --- a/pvDataApp/pv/pvData.h +++ b/pvDataApp/pv/pvData.h @@ -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(pv); + shareData(pvr.getSharedVector(), pvr.getCapacity(), pvr.getLength()); + } else { + setLength(pv.getLength()); + pv.getAs(typeCode, (void*)get(), std::min(getLength(),pv.getLength()), 0); + } } protected: diff --git a/testApp/pv/testConvert.cpp b/testApp/pv/testConvert.cpp index 48763d0..ab54135 100644 --- a/testApp/pv/testConvert.cpp +++ b/testApp/pv/testConvert.cpp @@ -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");