From e9b0dcd9f4a521d023becdee3fe0ab5ae8f46693 Mon Sep 17 00:00:00 2001 From: Marty Kraimer Date: Mon, 21 May 2012 10:06:28 -0400 Subject: [PATCH] lots of work on Scalar Arrays --- pvDataApp/factory/Convert.cpp | 138 ++++++--- pvDataApp/factory/PVDataCreateFactory.cpp | 7 +- pvDataApp/factory/PVStructure.cpp | 1 - pvDataApp/factory/PVStructureArray.cpp | 1 - pvDataApp/pv/convert.h | 82 ++++-- pvDataApp/pv/pvData.h | 19 +- pvDataApp/pv/pvType.h | 98 +++++-- testApp/pv/Makefile | 4 + testApp/pv/testConvert.cpp | 7 - testApp/pv/testPVScalarArray.cpp | 337 ++++++++++++++++++++++ 10 files changed, 588 insertions(+), 106 deletions(-) create mode 100644 testApp/pv/testPVScalarArray.cpp diff --git a/pvDataApp/factory/Convert.cpp b/pvDataApp/factory/Convert.cpp index 39d862e..23e1af3 100644 --- a/pvDataApp/factory/Convert.cpp +++ b/pvDataApp/factory/Convert.cpp @@ -15,7 +15,6 @@ #include using std::tr1::static_pointer_cast; -using std::tr1::const_pointer_cast; using std::size_t; namespace epics { namespace pvData { @@ -332,49 +331,49 @@ void Convert::fromDouble(PVScalarPtr const &pv, double from) static bool convertEquals(PVField *a,PVField *b); static size_t convertFromByteArray(PVScalarArray * pv, size_t offset, - size_t len,int8 from[], size_t fromOffset); + size_t len,const int8 from[], size_t fromOffset); static size_t convertToByteArray(PVScalarArray *pv, size_t offset, size_t len,int8 to[], size_t toOffset); static size_t convertFromShortArray(PVScalarArray *pv, size_t offset, - size_t len,int16 from[], size_t fromOffset); + size_t len,const int16 from[], size_t fromOffset); static size_t convertToShortArray(PVScalarArray *pv, size_t offset, size_t len,int16 to[], size_t toOffset); static size_t convertFromIntArray(PVScalarArray *pv, size_t offset, - size_t len,int32 from[], size_t fromOffset); + size_t len,const int32 from[], size_t fromOffset); static size_t convertToIntArray(PVScalarArray *pv, size_t offset, size_t len,int32 to[], size_t toOffset); static size_t convertFromLongArray(PVScalarArray *pv, size_t offset, - size_t len,int64 from[], size_t fromOffset); + size_t len,const int64 from[], size_t fromOffset); static size_t convertToLongArray(PVScalarArray * pv, size_t offset, size_t len,int64 to[], size_t toOffset); static size_t convertFromUByteArray(PVScalarArray * pv, size_t offset, - size_t len,uint8 from[], size_t fromOffset); + size_t len,const uint8 from[], size_t fromOffset); static size_t convertToUByteArray(PVScalarArray *pv, size_t offset, size_t len,uint8 to[], size_t toOffset); static size_t convertFromUShortArray(PVScalarArray *pv, size_t offset, - size_t len,uint16 from[], size_t fromOffset); + size_t len,const uint16 from[], size_t fromOffset); static size_t convertToUShortArray(PVScalarArray *pv, size_t offset, size_t len,uint16 to[], size_t toOffset); static size_t convertFromUIntArray(PVScalarArray *pv, size_t offset, - size_t len,uint32 from[], size_t fromOffset); + size_t len,const uint32 from[], size_t fromOffset); static size_t convertToUIntArray(PVScalarArray *pv, size_t offset, size_t len,uint32 to[], size_t toOffset); static size_t convertFromULongArray(PVScalarArray *pv, size_t offset, - size_t len,uint64 from[], size_t fromOffset); + size_t len,const uint64 from[], size_t fromOffset); static size_t convertToULongArray(PVScalarArray * pv, size_t offset, size_t len,uint64 to[], size_t toOffset); static size_t convertFromFloatArray(PVScalarArray *pv, size_t offset, - size_t len,float from[], size_t fromOffset); + size_t len,const float from[], size_t fromOffset); static size_t convertToFloatArray(PVScalarArray * pv, size_t offset, size_t len,float to[], size_t toOffset); static size_t convertFromDoubleArray(PVScalarArray *pv, size_t offset, - size_t len,double from[], size_t fromOffset); + size_t len,const double from[], size_t fromOffset); static size_t convertToDoubleArray(PVScalarArray *pv, size_t offset, size_t len,double to[], size_t toOffset); static size_t convertFromStringArray(PVScalarArray *pv, size_t offset, - size_t len,StringArray const & from, size_t fromOffset); + size_t len,const StringArray & from, size_t fromOffset); static size_t convertToStringArray(PVScalarArray *pv, size_t offset, - size_t len,StringArray const & to, size_t toOffset); + size_t len,StringArray & to, size_t toOffset); static void convertToString(StringBuilder buffer, PVField *pv,int indentLevel); @@ -627,7 +626,7 @@ size_t Convert::fromStringArray(PVScalarArrayPtr const &pv, size_t offset, size_ } size_t Convert::toStringArray(PVScalarArrayPtr const & pv, size_t offset, size_t length, - StringArray const &to, size_t toOffset) + StringArray &to, size_t toOffset) { return convertToStringArray(pv.get(),offset,length,to,toOffset); } @@ -1235,65 +1234,125 @@ size_t Convert::toDoubleArray(PVScalarArrayPtr const &pv, size_t offset, size_t } size_t Convert::fromByteArray(PVScalarArrayPtr const &pv, size_t offset, size_t length, - int8 from[], size_t fromOffset) + const int8 from[], size_t fromOffset) { return convertFromByteArray(pv.get(), offset, length, from, fromOffset); } +size_t Convert::fromByteArray(PVScalarArrayPtr const &pv, size_t offset, size_t length, + const ByteArray & from, size_t fromOffset) +{ + return convertFromByteArray(pv.get(), offset, length, get(from), fromOffset); +} + size_t Convert::fromShortArray(PVScalarArrayPtr const &pv, size_t offset, size_t length, - int16 from[], size_t fromOffset) + const int16 from[], size_t fromOffset) { return convertFromShortArray(pv.get(), offset, length, from, fromOffset); } +size_t Convert::fromShortArray(PVScalarArrayPtr const &pv, size_t offset, size_t length, + const ShortArray & from, size_t fromOffset) +{ + return convertFromShortArray(pv.get(), offset, length, get(from), fromOffset); +} + size_t Convert::fromIntArray(PVScalarArrayPtr const &pv, size_t offset, size_t length, - int32 from[], size_t fromOffset) + const int32 from[], size_t fromOffset) { return convertFromIntArray(pv.get(), offset, length, from, fromOffset); } +size_t Convert::fromIntArray(PVScalarArrayPtr const &pv, size_t offset, size_t length, + const IntArray & from, size_t fromOffset) +{ + return convertFromIntArray(pv.get(), offset, length, get(from), fromOffset); +} + size_t Convert::fromLongArray(PVScalarArrayPtr const &pv, size_t offset, size_t length, - int64 from[], size_t fromOffset) + const int64 from[], size_t fromOffset) { return convertFromLongArray(pv.get(), offset, length, from, fromOffset); } +size_t Convert::fromLongArray(PVScalarArrayPtr const &pv, size_t offset, size_t length, + const LongArray & from, size_t fromOffset) +{ + return convertFromLongArray(pv.get(), offset, length, get(from), fromOffset); +} + size_t Convert::fromUByteArray(PVScalarArrayPtr const &pv, size_t offset, size_t length, - uint8 from[], size_t fromOffset) + const uint8 from[], size_t fromOffset) { return convertFromUByteArray(pv.get(), offset, length, from, fromOffset); } +size_t Convert::fromUByteArray(PVScalarArrayPtr const &pv, size_t offset, size_t length, + const UByteArray & from, size_t fromOffset) +{ + return convertFromUByteArray(pv.get(), offset, length, get(from), fromOffset); +} + size_t Convert::fromUShortArray(PVScalarArrayPtr const &pv, size_t offset, size_t length, - uint16 from[], size_t fromOffset) + const uint16 from[], size_t fromOffset) { return convertFromUShortArray(pv.get(), offset, length, from, fromOffset); } +size_t Convert::fromUShortArray(PVScalarArrayPtr const &pv, size_t offset, size_t length, + const UShortArray &from, size_t fromOffset) +{ + return convertFromUShortArray(pv.get(), offset, length, get(from), fromOffset); +} + size_t Convert::fromUIntArray(PVScalarArrayPtr const &pv, size_t offset, size_t length, - uint32 from[], size_t fromOffset) + const uint32 from[], size_t fromOffset) { return convertFromUIntArray(pv.get(), offset, length, from, fromOffset); } +size_t Convert::fromUIntArray(PVScalarArrayPtr const &pv, size_t offset, size_t length, + const UIntArray & from, size_t fromOffset) +{ + return convertFromUIntArray(pv.get(), offset, length, get(from), fromOffset); +} + size_t Convert::fromULongArray(PVScalarArrayPtr const &pv, size_t offset, size_t length, - uint64 from[], size_t fromOffset) + const uint64 from[], size_t fromOffset) { return convertFromULongArray(pv.get(), offset, length, from, fromOffset); } +size_t Convert::fromULongArray(PVScalarArrayPtr const &pv, size_t offset, size_t length, + const ULongArray &from, size_t fromOffset) +{ + return convertFromULongArray(pv.get(), offset, length, get(from), fromOffset); +} + size_t Convert::fromFloatArray(PVScalarArrayPtr const &pv, size_t offset, size_t length, - float from[], size_t fromOffset) + const float from[], size_t fromOffset) { return convertFromFloatArray(pv.get(), offset, length, from, fromOffset); } +size_t Convert::fromFloatArray(PVScalarArrayPtr const &pv, size_t offset, size_t length, + const FloatArray & from, size_t fromOffset) +{ + return convertFromFloatArray(pv.get(), offset, length, get(from), fromOffset); +} + size_t Convert::fromDoubleArray(PVScalarArrayPtr const &pv, size_t offset, size_t length, - double from[], size_t fromOffset) + const double from[], size_t fromOffset) { return convertFromDoubleArray(pv.get(), offset, length, from, fromOffset); } +size_t Convert::fromDoubleArray(PVScalarArrayPtr const &pv, size_t offset, size_t length, + const DoubleArray & from, size_t fromOffset) +{ + return convertFromDoubleArray(pv.get(), offset, length, get(from), fromOffset); +} + void Convert::newLine(StringBuilder buffer, int indentLevel) { *buffer += "\n"; @@ -1637,7 +1696,7 @@ bool convertEquals(PVField *a,PVField *b) template size_t convertFromScalarArray(PVScalarArray *pv, - size_t offset, size_t len,T from[], size_t fromOffset) + size_t offset, size_t len,const T from[], size_t fromOffset) { ScalarType elemType = pv->getScalarArray()->getElementType(); size_t ntransfered = 0; @@ -2004,7 +2063,7 @@ size_t convertToScalarArray(PVScalarArray *pv, } size_t convertFromByteArray(PVScalarArray *pv, - size_t offset, size_t len,int8 from[], size_t fromOffset) + size_t offset, size_t len,const int8 from[], size_t fromOffset) { return convertFromScalarArray(pv,offset,len,from,fromOffset); } @@ -2016,7 +2075,7 @@ size_t convertToByteArray(PVScalarArray * pv, } size_t convertFromShortArray(PVScalarArray *pv, - size_t offset, size_t len,int16 from[], size_t fromOffset) + size_t offset, size_t len,const int16 from[], size_t fromOffset) { return convertFromScalarArray(pv,offset,len,from,fromOffset); } @@ -2028,7 +2087,7 @@ size_t convertToShortArray(PVScalarArray * pv, } size_t convertFromIntArray(PVScalarArray *pv, - size_t offset, size_t len,int32 from[], size_t fromOffset) + size_t offset, size_t len,const int32 from[], size_t fromOffset) { return convertFromScalarArray(pv,offset,len,from,fromOffset); } @@ -2040,7 +2099,7 @@ size_t convertToIntArray(PVScalarArray * pv, } size_t convertFromLongArray(PVScalarArray *pv, - size_t offset, size_t len,int64 from[], size_t fromOffset) + size_t offset, size_t len,const int64 from[], size_t fromOffset) { return convertFromScalarArray(pv,offset,len,from,fromOffset); } @@ -2052,7 +2111,7 @@ size_t convertToLongArray(PVScalarArray * pv, } size_t convertFromUByteArray(PVScalarArray *pv, - size_t offset, size_t len,uint8 from[], size_t fromOffset) + size_t offset, size_t len,const uint8 from[], size_t fromOffset) { return convertFromScalarArray(pv,offset,len,from,fromOffset); } @@ -2064,7 +2123,7 @@ size_t convertToUByteArray(PVScalarArray * pv, } size_t convertFromUShortArray(PVScalarArray *pv, - size_t offset, size_t len,uint16 from[], size_t fromOffset) + size_t offset, size_t len,const uint16 from[], size_t fromOffset) { return convertFromScalarArray(pv,offset,len,from,fromOffset); } @@ -2076,7 +2135,7 @@ size_t convertToUShortArray(PVScalarArray * pv, } size_t convertFromUIntArray(PVScalarArray *pv, - size_t offset, size_t len,uint32 from[], size_t fromOffset) + size_t offset, size_t len,const uint32 from[], size_t fromOffset) { return convertFromScalarArray(pv,offset,len,from,fromOffset); } @@ -2088,7 +2147,7 @@ size_t convertToUIntArray(PVScalarArray * pv, } size_t convertFromULongArray(PVScalarArray *pv, - size_t offset, size_t len,uint64 from[], size_t fromOffset) + size_t offset, size_t len,const uint64 from[], size_t fromOffset) { return convertFromScalarArray(pv,offset,len,from,fromOffset); } @@ -2100,7 +2159,7 @@ size_t convertToULongArray(PVScalarArray * pv, } size_t convertFromFloatArray(PVScalarArray *pv, - size_t offset, size_t len,float from[], size_t fromOffset) + size_t offset, size_t len,const float from[], size_t fromOffset) { return convertFromScalarArray(pv,offset,len,from,fromOffset); } @@ -2112,7 +2171,7 @@ size_t convertToFloatArray(PVScalarArray * pv, } size_t convertFromDoubleArray(PVScalarArray *pv, - size_t offset, size_t len,double from[], size_t fromOffset) + size_t offset, size_t len,const double from[], size_t fromOffset) { return convertFromScalarArray(pv,offset,len,from,fromOffset); } @@ -2124,7 +2183,7 @@ size_t convertToDoubleArray(PVScalarArray * pv, } size_t convertFromStringArray(PVScalarArray *pv, - size_t offset, size_t len,StringArray const & from, size_t fromOffset) + size_t offset, size_t len,const StringArray & from, size_t fromOffset) { ScalarType elemType = pv->getScalarArray()->getElementType(); size_t ntransfered = 0; @@ -2317,7 +2376,8 @@ size_t convertFromStringArray(PVScalarArray *pv, case pvString: PVStringArray *pvdata = static_cast(pv); while (len > 0) { - size_t n = pvdata->put(offset, len, get(from), fromOffset); + String * xxx = const_cast(get(from)); + size_t n = pvdata->put(offset, len, xxx, fromOffset); if (n == 0) break; len -= n; @@ -2332,9 +2392,9 @@ size_t convertFromStringArray(PVScalarArray *pv, } size_t convertToStringArray(PVScalarArray *pv, - size_t offset, size_t len,StringArray const & xxx, size_t toOffset) + size_t offset, size_t len,StringArray & xxx, size_t toOffset) { - String *to = const_cast(&xxx[0]); + String *to = &xxx[0]; ScalarType elementType = pv->getScalarArray()->getElementType(); size_t ncopy = pv->getLength(); if (ncopy > len) ncopy = len; diff --git a/pvDataApp/factory/PVDataCreateFactory.cpp b/pvDataApp/factory/PVDataCreateFactory.cpp index a53d906..9f7cfc2 100644 --- a/pvDataApp/factory/PVDataCreateFactory.cpp +++ b/pvDataApp/factory/PVDataCreateFactory.cpp @@ -19,7 +19,6 @@ #include using std::tr1::static_pointer_cast; -using std::tr1::const_pointer_cast; using std::size_t; namespace epics { namespace pvData { @@ -156,14 +155,16 @@ template class DefaultPVArray : public PVValueArray { public: typedef T* pointer; + typedef const T* const_pointer; typedef std::vector vector; + typedef const std::vector const_vector; typedef std::tr1::shared_ptr shared_vector; DefaultPVArray(ScalarArrayConstPtr const & scalarArray); virtual ~DefaultPVArray(); virtual void setCapacity(size_t capacity); virtual size_t get(size_t offset, size_t length, PVArrayData &data) ; - virtual size_t put(size_t offset,size_t length, pointer const from, + virtual size_t put(size_t offset,size_t length, const_pointer from, size_t fromOffset); virtual void shareData( std::tr1::shared_ptr > const & value, @@ -245,7 +246,7 @@ size_t DefaultPVArray::get(size_t offset, size_t len, PVArrayData &data) template size_t DefaultPVArray::put(size_t offset,size_t len, - pointer const from,size_t fromOffset) + const_pointer from,size_t fromOffset) { if(PVField::isImmutable()) { PVField::message("field is immutable",errorMessage); diff --git a/pvDataApp/factory/PVStructure.cpp b/pvDataApp/factory/PVStructure.cpp index ff4df95..04ae4f8 100644 --- a/pvDataApp/factory/PVStructure.cpp +++ b/pvDataApp/factory/PVStructure.cpp @@ -16,7 +16,6 @@ #include using std::tr1::static_pointer_cast; -using std::tr1::const_pointer_cast; using std::size_t; namespace epics { namespace pvData { diff --git a/pvDataApp/factory/PVStructureArray.cpp b/pvDataApp/factory/PVStructureArray.cpp index dc36b75..e8b898e 100644 --- a/pvDataApp/factory/PVStructureArray.cpp +++ b/pvDataApp/factory/PVStructureArray.cpp @@ -14,7 +14,6 @@ #include using std::tr1::static_pointer_cast; -using std::tr1::const_pointer_cast; using std::size_t; namespace epics { namespace pvData { diff --git a/pvDataApp/pv/convert.h b/pvDataApp/pv/convert.h index 95722c4..504ec43 100644 --- a/pvDataApp/pv/convert.h +++ b/pvDataApp/pv/convert.h @@ -169,7 +169,7 @@ public: * @return Number of elements converted. */ std::size_t toStringArray(PVScalarArrayPtr const & pv, std::size_t offset, std::size_t length, - StringArray const & to, std::size_t toOffset); + StringArray & to, std::size_t toOffset); /** * Are from and to valid arguments to copy. * This first checks of both arguments have the same Type. @@ -544,8 +544,12 @@ public: * @return number of elements converted * @throws std::invalid_argument if the element type is not numeric */ - std::size_t fromByteArray(PVScalarArrayPtr const & pv, std::size_t offset, std::size_t length, - int8* frim, std::size_t fromOffset); + std::size_t fromByteArray( + PVScalarArrayPtr const & pv, std::size_t offset, std::size_t length, + const int8* from, std::size_t fromOffset); + std::size_t fromByteArray( + PVScalarArrayPtr const & pv, std::size_t offset, std::size_t length, + const ByteArray & from, std::size_t fromOffset); /** * Convert a PV array from a short array. * @param pv a PV @@ -556,8 +560,12 @@ public: * @return number of elements converted * @throws std::invalid_argument if the element type is not numeric */ - std::size_t fromShortArray(PVScalarArrayPtr const & pv, std::size_t offset, std::size_t length, - int16* frim, std::size_t fromOffset); + std::size_t fromShortArray( + PVScalarArrayPtr const & pv, std::size_t offset, std::size_t length, + const int16* from, std::size_t fromOffset); + std::size_t fromShortArray( + PVScalarArrayPtr const & pv, std::size_t offset, std::size_t length, + const ShortArray & from, std::size_t fromOffset); /** * Convert a PV array from an int array. * @param pv a PV @@ -568,8 +576,12 @@ public: * @return number of elements converted * @throws std::invalid_argument if the element type is not numeric */ - std::size_t fromIntArray(PVScalarArrayPtr const & pv, std::size_t offset, std::size_t length, - int32* frim, std::size_t fromOffset); + std::size_t fromIntArray( + PVScalarArrayPtr const & pv, std::size_t offset, std::size_t length, + const int32* from, std::size_t fromOffset); + std::size_t fromIntArray( + PVScalarArrayPtr const & pv, std::size_t offset, std::size_t length, + const IntArray & from, std::size_t fromOffset); /** * Convert a PV array from a long array. * @param pv a PV @@ -580,8 +592,12 @@ public: * @return number of elements converted * @throws std::invalid_argument if the element type is not numeric */ - std::size_t fromLongArray(PVScalarArrayPtr const & pv, std::size_t offset, std::size_t length, - int64* frim, std::size_t fromOffset); + std::size_t fromLongArray( + PVScalarArrayPtr const & pv, std::size_t offset, std::size_t length, + const int64* from, std::size_t fromOffset); + std::size_t fromLongArray( + PVScalarArrayPtr const & pv, std::size_t offset, std::size_t length, + const LongArray & from, std::size_t fromOffset); /** * Convert a PV array from a ubyte array. * @param pv a PV @@ -592,8 +608,12 @@ public: * @return number of elements converted * @throws std::invalid_argument if the element type is not numeric */ - std::size_t fromUByteArray(PVScalarArrayPtr const & pv, std::size_t offset, std::size_t length, - uint8* frim, std::size_t fromOffset); + std::size_t fromUByteArray( + PVScalarArrayPtr const & pv, std::size_t offset, std::size_t length, + const uint8* from, std::size_t fromOffset); + std::size_t fromUByteArray( + PVScalarArrayPtr const & pv, std::size_t offset, std::size_t length, + const UByteArray & from, std::size_t fromOffset); /** * Convert a PV array from a ushort array. * @param pv a PV @@ -604,8 +624,12 @@ public: * @return number of elements converted * @throws std::invalid_argument if the element type is not numeric */ - std::size_t fromUShortArray(PVScalarArrayPtr const & pv, std::size_t offset, std::size_t length, - uint16* frim, std::size_t fromOffset); + std::size_t fromUShortArray( + PVScalarArrayPtr const & pv, std::size_t offset, std::size_t length, + const uint16* from, std::size_t fromOffset); + std::size_t fromUShortArray( + PVScalarArrayPtr const & pv, std::size_t offset, std::size_t length, + const UShortArray & from, std::size_t fromOffset); /** * Convert a PV array from an uint array. * @param pv a PV @@ -616,8 +640,12 @@ public: * @return number of elements converted * @throws std::invalid_argument if the element type is not numeric */ - std::size_t fromUIntArray(PVScalarArrayPtr const & pv, std::size_t offset, std::size_t length, - uint32* frim, std::size_t fromOffset); + std::size_t fromUIntArray( + PVScalarArrayPtr const & pv, std::size_t offset, std::size_t length, + const uint32* from, std::size_t fromOffset); + std::size_t fromUIntArray( + PVScalarArrayPtr const & pv, std::size_t offset, std::size_t length, + const UIntArray & from, std::size_t fromOffset); /** * Convert a PV array from a ulong array. * @param pv a PV @@ -628,8 +656,12 @@ public: * @return number of elements converted * @throws std::invalid_argument if the element type is not numeric */ - std::size_t fromULongArray(PVScalarArrayPtr const & pv, std::size_t offset, std::size_t length, - uint64* frim, std::size_t fromOffset); + std::size_t fromULongArray( + PVScalarArrayPtr const & pv, std::size_t offset, std::size_t length, + const uint64* from, std::size_t fromOffset); + std::size_t fromULongArray( + PVScalarArrayPtr const & pv, std::size_t offset, std::size_t length, + const ULongArray & from, std::size_t fromOffset); /** * Convert a PV array from a float array. * @param pv a PV @@ -640,8 +672,12 @@ public: * @return number of elements converted * @throws std::invalid_argument if the element type is not numeric */ - std::size_t fromFloatArray(PVScalarArrayPtr const & pv, std::size_t offset, std::size_t length, - float* frim, std::size_t fromOffset); + std::size_t fromFloatArray( + PVScalarArrayPtr const & pv, std::size_t offset, std::size_t length, + const float* from, std::size_t fromOffset); + std::size_t fromFloatArray( + PVScalarArrayPtr const & pv, std::size_t offset, std::size_t length, + const FloatArray & from, std::size_t fromOffset); /** * Convert a PV array from a double array. * @param pv a PV @@ -652,8 +688,12 @@ public: * @return number of elements converted * @throws std::invalid_argument if the element type is not numeric */ - std::size_t fromDoubleArray(PVScalarArrayPtr const & pv, std::size_t offset, std::size_t length, - double* frim, std::size_t fromOffset); + std::size_t fromDoubleArray( + PVScalarArrayPtr const & pv, std::size_t offset, std::size_t length, + const double* from, std::size_t fromOffset); + std::size_t fromDoubleArray( + PVScalarArrayPtr const & pv, std::size_t offset, std::size_t length, + const DoubleArray & from, std::size_t fromOffset); /** * Convenience method for implementing toString. * It generates a newline and inserts blanks at the beginning of the newline. diff --git a/pvDataApp/pv/pvData.h b/pvDataApp/pv/pvData.h index 4b2ce1c..4975f15 100644 --- a/pvDataApp/pv/pvData.h +++ b/pvDataApp/pv/pvData.h @@ -329,7 +329,7 @@ private: /** * typedefs for the various possible scalar types. */ -typedef PVScalarValue PVBoolean; +typedef PVScalarValue PVBoolean; typedef PVScalarValue PVByte; typedef PVScalarValue PVShort; typedef PVScalarValue PVInt; @@ -770,6 +770,7 @@ public: typedef const T* const_pointer; typedef PVArrayData ArrayDataType; typedef std::vector vector; + typedef const std::vector const_vector; typedef std::tr1::shared_ptr shared_vector; typedef PVValueArray & reference; typedef const PVValueArray & const_reference; @@ -795,7 +796,9 @@ public: * @return The number of elements put into the array. */ virtual std::size_t put(std::size_t offset, - std::size_t length, pointer const from, std::size_t fromOffset) = 0; + std::size_t length, const_pointer from, std::size_t fromOffset) = 0; + virtual std::size_t put(std::size_t offset, + std::size_t length, const_vector &from, std::size_t fromOffset); /** * Share data from another source. * @param value The data to share. @@ -816,11 +819,19 @@ protected: friend class PVDataCreate; }; +template +std::size_t PVValueArray::put( + std::size_t offset, + std::size_t length, + const_vector &from, + std::size_t fromOffset) +{ return put(offset,length, &from[0], fromOffset); } + /** * Definitions for the various scalarArray types. */ -typedef PVArrayData BooleanArrayData; -typedef PVValueArray PVBooleanArray; +typedef PVArrayData BooleanArrayData; +typedef PVValueArray PVBooleanArray; typedef std::tr1::shared_ptr PVBooleanArrayPtr; typedef PVArrayData ByteArrayData; diff --git a/pvDataApp/pv/pvType.h b/pvDataApp/pv/pvType.h index e9f2a00..50f4ff2 100644 --- a/pvDataApp/pv/pvType.h +++ b/pvDataApp/pv/pvType.h @@ -69,23 +69,21 @@ typedef std::string String; /** * A boolean array. */ -typedef std::vector BooleanArray; -// get will be the same as for UByte -/* -inline boolean * get(BooleanArray value) -{ - return const_cast(&value[0]); -} -*/ +typedef std::vector BooleanArray; +/* get is same is UInt */ typedef std::vector::iterator BooleanArray_iterator; typedef std::vector::const_iterator BooleanArray_const_iterator; /** * A byte array. */ typedef std::vector ByteArray; -inline int8 * get(ByteArray value) +inline int8 * get(ByteArray &value) { - return const_cast(&value[0]); + return &value[0]; +} +inline const int8 * get(const ByteArray &value) +{ + return static_cast(&value[0]); } typedef std::vector::iterator ByteArray_iterator; typedef std::vector::const_iterator ByteArray_const_iterator; @@ -93,9 +91,13 @@ typedef std::vector::const_iterator ByteArray_const_iterator; * A short array. */ typedef std::vector ShortArray; -inline int16 * get(ShortArray value) +inline int16 * get(ShortArray &value) { - return const_cast(&value[0]); + return &value[0]; +} +inline const int16 * get(const ShortArray &value) +{ + return static_cast(&value[0]); } typedef std::vector::iterator ShortArray_iterator; typedef std::vector::const_iterator ShortArray_const_iterator; @@ -103,9 +105,13 @@ typedef std::vector::const_iterator ShortArray_const_iterator; * A int array. */ typedef std::vector IntArray; -inline int32 * get(IntArray value) +inline int32 * get(IntArray &value) { - return const_cast(&value[0]); + return &value[0]; +} +inline const int32 * get(const IntArray &value) +{ + return static_cast(&value[0]); } typedef std::vector::iterator IntArray_iterator; typedef std::vector::const_iterator IntArray_const_iterator; @@ -113,9 +119,13 @@ typedef std::vector::const_iterator IntArray_const_iterator; * A long array. */ typedef std::vector LongArray; -inline int64 * get(LongArray value) +inline int64 * get(LongArray &value) { - return const_cast(&value[0]); + return &value[0]; +} +inline const int64 * get(const LongArray &value) +{ + return static_cast(&value[0]); } typedef std::vector::iterator LongArray_iterator; typedef std::vector::const_iterator LongArray_const_iterator; @@ -123,9 +133,13 @@ typedef std::vector::const_iterator LongArray_const_iterator; * An unsigned byte array. */ typedef std::vector UByteArray; -inline uint8 * get(UByteArray value) +inline uint8 * get(UByteArray &value) { - return const_cast(&value[0]); + return &value[0]; +} +inline const uint8 * get(const UByteArray &value) +{ + return static_cast(&value[0]); } typedef std::vector::iterator UByteArray_iterator; typedef std::vector::const_iterator UByteArray_const_iterator; @@ -133,9 +147,13 @@ typedef std::vector::const_iterator UByteArray_const_iterator; * An unsigned short array. */ typedef std::vector UShortArray; -inline uint16 * get(UShortArray value) +inline uint16 * get(UShortArray &value) { - return const_cast(&value[0]); + return &value[0]; +} +inline const uint16 * get(const UShortArray &value) +{ + return static_cast(&value[0]); } typedef std::vector::iterator UShortArray_iterator; typedef std::vector::const_iterator UShortArray_const_iterator; @@ -143,9 +161,13 @@ typedef std::vector::const_iterator UShortArray_const_iterator; * An unsigned int array. */ typedef std::vector UIntArray; -inline uint32 * get(UIntArray value) +inline uint32 * get(UIntArray &value) { - return const_cast(&value[0]); + return &value[0]; +} +inline const uint32 * get(const UIntArray &value) +{ + return static_cast(&value[0]); } typedef std::vector::iterator UIntArray_iterator; typedef std::vector::const_iterator UIntArray_const_iterator; @@ -153,9 +175,13 @@ typedef std::vector::const_iterator UIntArray_const_iterator; * An unsigned long array. */ typedef std::vector ULongArray; -inline uint64 * get(ULongArray value) +inline uint64 * get(ULongArray &value) { - return const_cast(&value[0]); + return &value[0]; +} +inline const uint64 * get(const ULongArray &value) +{ + return static_cast(&value[0]); } typedef std::vector::iterator ULongArray_iterator; typedef std::vector::const_iterator ULongArray_const_iterator; @@ -163,9 +189,13 @@ typedef std::vector::const_iterator ULongArray_const_iterator; * A float array. */ typedef std::vector FloatArray; -inline float * get(FloatArray value) +inline float * get(FloatArray &value) { - return const_cast(&value[0]); + return &value[0]; +} +inline const float * get(const FloatArray &value) +{ + return static_cast(&value[0]); } typedef std::vector::iterator FloatArray_iterator; typedef std::vector::const_iterator FloatArray_const_iterator; @@ -173,9 +203,13 @@ typedef std::vector::const_iterator FloatArray_const_iterator; * A double array. */ typedef std::vector DoubleArray; -inline double * get(DoubleArray value) +inline double * get(DoubleArray &value) { - return const_cast(&value[0]); + return &value[0]; +} +inline const double * get(const DoubleArray &value) +{ + return static_cast(&value[0]); } typedef std::vector::iterator DoubleArray_iterator; typedef std::vector::const_iterator DoubleArray_const_iterator; @@ -183,9 +217,13 @@ typedef std::vector::const_iterator DoubleArray_const_iterator; * A string array. */ typedef std::vector StringArray; -inline String * get(StringArray value) +inline String * get(StringArray &value) { - return const_cast(&value[0]); + return &value[0]; +} +inline const String * get(const StringArray &value) +{ + return static_cast(&value[0]); } typedef std::vector::iterator StringArray_iterator; typedef std::vector::const_iterator StringArray_const_iterator; diff --git a/testApp/pv/Makefile b/testApp/pv/Makefile index 5b5a430..e0936b6 100644 --- a/testApp/pv/Makefile +++ b/testApp/pv/Makefile @@ -26,6 +26,10 @@ PROD_HOST += testConvert testConvert_SRCS += testConvert.cpp testConvert_LIBS += pvData Com +PROD_HOST += testPVScalarArray +testPVScalarArray_SRCS += testPVScalarArray.cpp +testPVScalarArray_LIBS += pvData Com + PROD_HOST += testPVStructureArray testPVStructureArray_SRCS += testPVStructureArray.cpp testPVStructureArray_LIBS += pvData Com diff --git a/testApp/pv/testConvert.cpp b/testApp/pv/testConvert.cpp index deda274..81c2ed0 100644 --- a/testApp/pv/testConvert.cpp +++ b/testApp/pv/testConvert.cpp @@ -570,13 +570,6 @@ static void testConvertScalarArray(FILE *fd) { convert->copyScalarArray(pvULongPtr,0, pvDoublePtr,0,length); builder.clear(); pvDoublePtr->toString(&builder); fprintf(fd,"double from unsigned %s\n",builder.c_str()); -ULongArrayData arrayData = ULongArrayData(); -PVULongArrayPtr xxx = static_pointer_cast(pvULongPtr); -xxx->get(0,length,arrayData); -uint64 * data = get(arrayData.data); -printf("data %p %lli %lli %lli %lli\n",data,data[0],data[1],data[2],data[3]); -uint64 val = arrayData.data[0]; -printf("val %p %lli\n",&(arrayData.data[0]),val); } int main(int argc,char *argv[]) diff --git a/testApp/pv/testPVScalarArray.cpp b/testApp/pv/testPVScalarArray.cpp new file mode 100644 index 0000000..44bce23 --- /dev/null +++ b/testApp/pv/testPVScalarArray.cpp @@ -0,0 +1,337 @@ +/* testPVScalarArray.cpp */ +/** + * Copyright - See the COPYRIGHT that is included with this distribution. + * EPICS pvDataCPP is distributed subject to a Software License Agreement found + * in file LICENSE that is included with this distribution. + */ +/* Author: Marty Kraimer Date: 2010.11 */ + +#include +#include +#include +#include +#include + +#include +#include + +#include +#include +#include +#include +#include +#include + +using namespace epics::pvData; +using std::tr1::static_pointer_cast; + +static FieldCreatePtr fieldCreate; +static PVDataCreatePtr pvDataCreate; +static StandardFieldPtr standardField; +static StandardPVFieldPtr standardPVField; +static ConvertPtr convert; +static String builder(""); +static String alarmTimeStamp("alarm,timeStamp"); +static String alarmTimeStampValueAlarm("alarm,timeStamp,valueAlarm"); +static String allProperties("alarm,timeStamp,display,control,valueAlarm"); +static FILE * fd = NULL; +static size_t length = 4; + +static void byteArray() +{ + PVScalarArrayPtr pvScalarArray = pvDataCreate->createPVScalarArray(pvByte);; + PVByteArrayPtr pvByteArray = static_pointer_cast(pvScalarArray); + ByteArray value; + value.reserve(length); + int8 xxx = 0x7f; + for(size_t i = 0; iput(0,length,value,0); + builder.clear(); + pvByteArray->toString(&builder); + fprintf(fd,"put\n%s\n",builder.c_str()); + convert->fromByteArray(pvScalarArray,0,length,value,0); + builder.clear(); + pvByteArray->toString(&builder); + fprintf(fd,"convert\n%s\n",builder.c_str()); + ByteArrayData data; + pvByteArray->get(0,length,data); + ByteArray_iterator iter = data.data.begin(); + fprintf(fd,"iter ["); + for(iter=data.data.begin();iter!=data.data.end();++iter) { + fprintf(fd,"%d ",*iter); + } + fprintf(fd,"]\n"); + fprintf(fd,"raw ["); + int8 * pdata = get(data.data); + for(size_t i=0; icreatePVScalarArray(pvUByte);; + PVUByteArrayPtr pvUByteArray = static_pointer_cast(pvScalarArray); + UByteArray value; + value.reserve(length); + uint8 xxx = 0x7f; + for(size_t i = 0; iput(0,length,value,0); + builder.clear(); + pvUByteArray->toString(&builder); + fprintf(fd,"put\n%s\n",builder.c_str()); + convert->fromUByteArray(pvScalarArray,0,length,value,0); + builder.clear(); + pvUByteArray->toString(&builder); + fprintf(fd,"convert\n%s\n",builder.c_str()); + UByteArrayData data; + pvUByteArray->get(0,length,data); + UByteArray_iterator iter = data.data.begin(); + fprintf(fd,"iter ["); + for(iter=data.data.begin();iter!=data.data.end();++iter) { + fprintf(fd,"%u ",*iter); + } + fprintf(fd,"]\n"); + fprintf(fd,"raw ["); + uint8 * pdata = get(data.data); + for(size_t i=0; icreatePVScalarArray(pvLong);; + PVLongArrayPtr pvLongArray = static_pointer_cast(pvScalarArray); + LongArray value; + value.reserve(length); + int64 xxx = 0x7fffffffffffffffL; + for(size_t i = 0; iput(0,length,value,0); + builder.clear(); + pvLongArray->toString(&builder); + fprintf(fd,"put\n%s\n",builder.c_str()); + convert->fromLongArray(pvScalarArray,0,length,value,0); + builder.clear(); + pvLongArray->toString(&builder); + fprintf(fd,"convert\n%s\n",builder.c_str()); + LongArrayData data; + pvLongArray->get(0,length,data); + LongArray_iterator iter = data.data.begin(); + fprintf(fd,"iter ["); + for(iter=data.data.begin();iter!=data.data.end();++iter) { + fprintf(fd,"%lli ",*iter); + } + fprintf(fd,"]\n"); + fprintf(fd,"raw ["); + int64 * pdata = get(data.data); + for(size_t i=0; icreatePVScalarArray(pvULong);; + PVULongArrayPtr pvULongArray = static_pointer_cast(pvScalarArray); + ULongArray value; + value.reserve(length); + uint64 xxx = 0x7fffffffffffffffL; + for(size_t i = 0; iput(0,length,value,0); + builder.clear(); + pvULongArray->toString(&builder); + fprintf(fd,"put\n%s\n",builder.c_str()); + convert->fromULongArray(pvScalarArray,0,length,value,0); + builder.clear(); + pvULongArray->toString(&builder); + fprintf(fd,"convert\n%s\n",builder.c_str()); + ULongArrayData data; + pvULongArray->get(0,length,data); + ULongArray_iterator iter = data.data.begin(); + fprintf(fd,"iter ["); + for(iter=data.data.begin();iter!=data.data.end();++iter) { + fprintf(fd,"%llu ",*iter); + } + fprintf(fd,"]\n"); + fprintf(fd,"raw ["); + uint64 * pdata = get(data.data); + for(size_t i=0; icreatePVScalarArray(pvFloat);; + PVFloatArrayPtr pvFloatArray = static_pointer_cast(pvScalarArray); + FloatArray value; + value.reserve(length); + for(size_t i = 0; iput(0,length,value,0); + builder.clear(); + pvFloatArray->toString(&builder); + fprintf(fd,"put\n%s\n",builder.c_str()); + convert->fromFloatArray(pvScalarArray,0,length,value,0); + builder.clear(); + pvFloatArray->toString(&builder); + fprintf(fd,"convert\n%s\n",builder.c_str()); + FloatArrayData data; + pvFloatArray->get(0,length,data); + FloatArray_iterator iter = data.data.begin(); + fprintf(fd,"iter ["); + for(iter=data.data.begin();iter!=data.data.end();++iter) { + fprintf(fd,"%f ",*iter); + } + fprintf(fd,"]\n"); + fprintf(fd,"raw ["); + float * pdata = get(data.data); + for(size_t i=0; icreatePVScalarArray(pvDouble);; + PVDoubleArrayPtr pvDoubleArray = static_pointer_cast(pvScalarArray); + DoubleArray value; + value.reserve(length); + for(size_t i = 0; iput(0,length,value,0); + builder.clear(); + pvDoubleArray->toString(&builder); + fprintf(fd,"put\n%s\n",builder.c_str()); + convert->fromDoubleArray(pvScalarArray,0,length,value,0); + builder.clear(); + pvDoubleArray->toString(&builder); + fprintf(fd,"convert\n%s\n",builder.c_str()); + DoubleArrayData data; + pvDoubleArray->get(0,length,data); + DoubleArray_iterator iter = data.data.begin(); + fprintf(fd,"iter ["); + for(iter=data.data.begin();iter!=data.data.end();++iter) { + fprintf(fd,"%lf ",*iter); + } + fprintf(fd,"]\n"); + fprintf(fd,"raw ["); + double * pdata = get(data.data); + for(size_t i=0; icreatePVScalarArray(pvString);; + PVStringArrayPtr pvStringArray = static_pointer_cast(pvScalarArray); + StringArray value; + value.reserve(length); + for(int i = 0; iput(0,length,value,0); + builder.clear(); + pvStringArray->toString(&builder); + fprintf(fd,"put\n%s\n",builder.c_str()); + convert->fromStringArray(pvScalarArray,0,length,value,0); + builder.clear(); + pvStringArray->toString(&builder); + fprintf(fd,"convert\n%s\n",builder.c_str()); + StringArrayData data; + pvStringArray->get(0,length,data); + StringArray_iterator iter = data.data.begin(); + fprintf(fd,"iter ["); + for(iter=data.data.begin();iter!=data.data.end();++iter) { + String val = *iter; + fprintf(fd,"%s ",val.c_str()); + } + fprintf(fd,"]\n"); + fprintf(fd,"raw ["); + String* pdata = get(data.data); + for(size_t i=0; i1) fileName = argv[1]; + fd = stdout; + if(fileName!=0 && fileName[0]!=0) { + fd = fopen(fileName,"w+"); + } + fieldCreate = getFieldCreate(); + pvDataCreate = getPVDataCreate(); + standardField = getStandardField(); + standardPVField = getStandardPVField(); + convert = getConvert(); + byteArray(); + ubyteArray(); + longArray(); + ulongArray(); + floatArray(); + doubleArray(); + stringArray(); + return(0); +} +