Convert: remove to/from*Array
This commit is contained in:
Michael Davidsaver
@@ -435,380 +435,7 @@ public:
|
||||
* @throws std::invalid_argument if the Type is not a numeric scalar
|
||||
*/
|
||||
inline void fromDouble(PVScalarPtr const & pv, double from) { pv->putFrom<pvDouble>(from); }
|
||||
/**
|
||||
* Convert a PV array to a byte array.
|
||||
* @param pv a PV
|
||||
* @param offset starting element in a PV
|
||||
* @param length number of elements to transfer
|
||||
* @param to where to put the PV data
|
||||
* @param toOffset starting element in the array
|
||||
* @return number of elements converted
|
||||
* @throws std::invalid_argument if the element type is not numeric
|
||||
*/
|
||||
inline
|
||||
std::size_t toByteArray(PVScalarArrayPtr const & pv,
|
||||
std::size_t offset,
|
||||
std::size_t length,
|
||||
int8* to,
|
||||
std::size_t toOffset)
|
||||
{ pv->getAs<pvByte>(to+toOffset, length, offset); return length; }
|
||||
/**
|
||||
* Convert a PV array to a short array.
|
||||
* @param pv a PV
|
||||
* @param offset starting element in a PV
|
||||
* @param length number of elements to transfer
|
||||
* @param to where to put the PV data
|
||||
* @param toOffset starting element in the array
|
||||
* @return number of elements converted
|
||||
* @throws std::invalid_argument if the element type is not numeric
|
||||
*/
|
||||
inline
|
||||
std::size_t toShortArray(PVScalarArrayPtr const & pv,
|
||||
std::size_t offset,
|
||||
std::size_t length,
|
||||
int16* to,
|
||||
std::size_t toOffset)
|
||||
{ pv->getAs<pvShort>(to+toOffset, length, offset); return length; }
|
||||
/**
|
||||
* Convert a PV array to an int array.
|
||||
* @param pv a PV
|
||||
* @param offset starting element in a PV
|
||||
* @param length number of elements to transfer
|
||||
* @param to where to put the PV data
|
||||
* @param toOffset starting element in the array
|
||||
* @return number of elements converted
|
||||
* @throws std::invalid_argument if the element type is not numeric
|
||||
*/
|
||||
inline
|
||||
std::size_t toIntArray(PVScalarArrayPtr const & pv,
|
||||
std::size_t offset,
|
||||
std::size_t length,
|
||||
int32* to,
|
||||
std::size_t toOffset)
|
||||
{ pv->getAs<pvInt>(to+toOffset, length, offset); return length; }
|
||||
/**
|
||||
* Convert a PV array to a long array.
|
||||
* @param pv a PV
|
||||
* @param offset starting element in a PV
|
||||
* @param length number of elements to transfer
|
||||
* @param to where to put the PV data
|
||||
* @param toOffset starting element in the array
|
||||
* @return number of elements converted
|
||||
* @throws std::invalid_argument if the element type is not numeric
|
||||
*/
|
||||
inline
|
||||
std::size_t toLongArray(PVScalarArrayPtr const & pv,
|
||||
std::size_t offset,
|
||||
std::size_t length,
|
||||
int64* to,
|
||||
std::size_t toOffset)
|
||||
{ pv->getAs<pvLong>(to+toOffset, length, offset); return length; }
|
||||
/**
|
||||
* Convert a PV array to a ubyte array.
|
||||
* @param pv a PV
|
||||
* @param offset starting element in a PV
|
||||
* @param length number of elements to transfer
|
||||
* @param to where to put the PV data
|
||||
* @param toOffset starting element in the array
|
||||
* @return number of elements converted
|
||||
* @throws std::invalid_argument if the element type is not numeric
|
||||
*/
|
||||
inline
|
||||
std::size_t toUByteArray(PVScalarArrayPtr const & pv,
|
||||
std::size_t offset,
|
||||
std::size_t length,
|
||||
uint8* to,
|
||||
std::size_t toOffset)
|
||||
{ pv->getAs<pvUByte>(to+toOffset, length, offset); return length; }
|
||||
/**
|
||||
* Convert a PV array to a ushort array.
|
||||
* @param pv a PV
|
||||
* @param offset starting element in a PV
|
||||
* @param length number of elements to transfer
|
||||
* @param to where to put the PV data
|
||||
* @param toOffset starting element in the array
|
||||
* @return number of elements converted
|
||||
* @throws std::invalid_argument if the element type is not numeric
|
||||
*/
|
||||
inline
|
||||
std::size_t toUShortArray(PVScalarArrayPtr const & pv,
|
||||
std::size_t offset,
|
||||
std::size_t length,
|
||||
uint16* to,
|
||||
std::size_t toOffset)
|
||||
{ pv->getAs<pvUShort>(to+toOffset, length, offset); return length; }
|
||||
/**
|
||||
* Convert a PV array to an uint array.
|
||||
* @param pv a PV
|
||||
* @param offset starting element in a PV
|
||||
* @param length number of elements to transfer
|
||||
* @param to where to put the PV data
|
||||
* @param toOffset starting element in the array
|
||||
* @return number of elements converted
|
||||
* @throws std::invalid_argument if the element type is not numeric
|
||||
*/
|
||||
inline
|
||||
std::size_t toUIntArray(
|
||||
PVScalarArrayPtr const & pv,
|
||||
std::size_t offset,
|
||||
std::size_t length,
|
||||
uint32* to,
|
||||
std::size_t toOffset)
|
||||
{ pv->getAs<pvUInt>(to+toOffset, length, offset); return length; }
|
||||
/**
|
||||
* Convert a PV array to a ulong array.
|
||||
* @param pv a PV
|
||||
* @param offset starting element in a PV
|
||||
* @param length number of elements to transfer
|
||||
* @param to where to put the PV data
|
||||
* @param toOffset starting element in the array
|
||||
* @return number of elements converted
|
||||
* @throws std::invalid_argument if the element type is not numeric
|
||||
*/
|
||||
inline
|
||||
std::size_t toULongArray(
|
||||
PVScalarArrayPtr const & pv,
|
||||
std::size_t offset,
|
||||
std::size_t length,
|
||||
uint64* to,
|
||||
std::size_t toOffset)
|
||||
{ pv->getAs<pvULong>(to+toOffset, length, offset); return length; }
|
||||
/**
|
||||
* Convert a PV array to a float array.
|
||||
* @param pv a PV
|
||||
* @param offset starting element in a PV
|
||||
* @param length number of elements to transfer
|
||||
* @param to where to put the PV data
|
||||
* @param toOffset starting element in the array
|
||||
* @return number of elements converted
|
||||
* @throws std::invalid_argument if the element type is not numeric
|
||||
*/
|
||||
inline
|
||||
std::size_t toFloatArray(
|
||||
PVScalarArrayPtr const & pv,
|
||||
std::size_t offset,
|
||||
std::size_t length,
|
||||
float* to,
|
||||
std::size_t toOffset)
|
||||
{ pv->getAs<pvFloat>(to+toOffset, length, offset); return length; }
|
||||
/**
|
||||
* Convert a PV array to a double array.
|
||||
* @param pv a PV
|
||||
* @param offset starting element in a PV
|
||||
* @param length number of elements to transfer
|
||||
* @param to where to put the PV data
|
||||
* @param toOffset starting element in the array
|
||||
* @return number of elements converted
|
||||
* @throws std::invalid_argument if the element type is not numeric
|
||||
*/
|
||||
inline
|
||||
std::size_t toDoubleArray(
|
||||
PVScalarArrayPtr const & pv,
|
||||
std::size_t offset,
|
||||
std::size_t length,
|
||||
double* to, std::size_t
|
||||
toOffset)
|
||||
{ pv->getAs<pvDouble>(to+toOffset, length, offset); return length; }
|
||||
/**
|
||||
* Convert a PV array from a byte array.
|
||||
* @param pv a PV
|
||||
* @param offset starting element in a PV
|
||||
* @param length number of elements to transfer
|
||||
* @param from value to put into PV
|
||||
* @param fromOffset
|
||||
* @return number of elements converted
|
||||
* @throws std::invalid_argument if the element type is not numeric
|
||||
*/
|
||||
inline
|
||||
std::size_t fromByteArray(
|
||||
PVScalarArrayPtr & pv, std::size_t offset, std::size_t length,
|
||||
const int8* from, std::size_t fromOffset)
|
||||
{ pv->putFrom<pvByte>(from+fromOffset, length, offset); return length; }
|
||||
inline
|
||||
std::size_t fromByteArray(
|
||||
PVScalarArrayPtr & pv, std::size_t offset, std::size_t length,
|
||||
const ByteArray & from, std::size_t fromOffset)
|
||||
{return fromByteArray(pv, offset, length, &from[0], fromOffset);}
|
||||
/**
|
||||
* Convert a PV array from a short array.
|
||||
* @param pv a PV
|
||||
* @param offset starting element in a PV
|
||||
* @param length number of elements to transfer
|
||||
* @param from value to put into PV
|
||||
* @param fromOffset starting element in the source array
|
||||
* @return number of elements converted
|
||||
* @throws std::invalid_argument if the element type is not numeric
|
||||
*/
|
||||
inline
|
||||
std::size_t fromShortArray(
|
||||
PVScalarArrayPtr & pv, std::size_t offset, std::size_t length,
|
||||
const int16* from, std::size_t fromOffset)
|
||||
{ pv->putFrom<pvShort>(from+fromOffset, length, offset); return length; }
|
||||
inline
|
||||
std::size_t fromShortArray(
|
||||
PVScalarArrayPtr & pv, std::size_t offset, std::size_t length,
|
||||
const ShortArray & from, std::size_t fromOffset)
|
||||
{return fromShortArray(pv, offset, length, &from[0], fromOffset);}
|
||||
/**
|
||||
* Convert a PV array from an int array.
|
||||
* @param pv a PV
|
||||
* @param offset starting element in a PV
|
||||
* @param length number of elements to transfer
|
||||
* @param from value to put into PV
|
||||
* @param fromOffset starting element in the source array
|
||||
* @return number of elements converted
|
||||
* @throws std::invalid_argument if the element type is not numeric
|
||||
*/
|
||||
inline
|
||||
std::size_t fromIntArray(
|
||||
PVScalarArrayPtr & pv, std::size_t offset, std::size_t length,
|
||||
const int32* from, std::size_t fromOffset)
|
||||
{ pv->putFrom<pvInt>(from+fromOffset, length, offset); return length; }
|
||||
inline
|
||||
std::size_t fromIntArray(
|
||||
PVScalarArrayPtr & pv, std::size_t offset, std::size_t length,
|
||||
const IntArray & from, std::size_t fromOffset)
|
||||
{return fromIntArray(pv, offset, length, &from[0], fromOffset);}
|
||||
/**
|
||||
* Convert a PV array from a long array.
|
||||
* @param pv a PV
|
||||
* @param offset starting element in a PV
|
||||
* @param length number of elements to transfer
|
||||
* @param from value to put into PV
|
||||
* @param fromOffset starting element in the source array
|
||||
* @return number of elements converted
|
||||
* @throws std::invalid_argument if the element type is not numeric
|
||||
*/
|
||||
inline
|
||||
std::size_t fromLongArray(
|
||||
PVScalarArrayPtr & pv, std::size_t offset, std::size_t length,
|
||||
const int64* from, std::size_t fromOffset)
|
||||
{ pv->putFrom<pvLong>(from+fromOffset, length, offset); return length; }
|
||||
inline
|
||||
std::size_t fromLongArray(
|
||||
PVScalarArrayPtr & pv, std::size_t offset, std::size_t length,
|
||||
const LongArray & from, std::size_t fromOffset)
|
||||
{return fromLongArray(pv, offset, length, &from[0], fromOffset);}
|
||||
/**
|
||||
* Convert a PV array from a ubyte array.
|
||||
* @param pv a PV
|
||||
* @param offset starting element in a PV
|
||||
* @param length number of elements to transfer
|
||||
* @param from value to put into PV
|
||||
* @param fromOffset
|
||||
* @return number of elements converted
|
||||
* @throws std::invalid_argument if the element type is not numeric
|
||||
*/
|
||||
inline
|
||||
std::size_t fromUByteArray(
|
||||
PVScalarArrayPtr & pv, std::size_t offset, std::size_t length,
|
||||
const uint8* from, std::size_t fromOffset)
|
||||
{ pv->putFrom<pvUByte>(from+fromOffset, length, offset); return length; }
|
||||
inline
|
||||
std::size_t fromUByteArray(
|
||||
PVScalarArrayPtr & pv, std::size_t offset, std::size_t length,
|
||||
const UByteArray & from, std::size_t fromOffset)
|
||||
{return fromUByteArray(pv, offset, length, &from[0], fromOffset);}
|
||||
/**
|
||||
* Convert a PV array from a ushort array.
|
||||
* @param pv a PV
|
||||
* @param offset starting element in a PV
|
||||
* @param length number of elements to transfer
|
||||
* @param from value to put into PV
|
||||
* @param fromOffset starting element in the source array
|
||||
* @return number of elements converted
|
||||
* @throws std::invalid_argument if the element type is not numeric
|
||||
*/
|
||||
inline
|
||||
std::size_t fromUShortArray(
|
||||
PVScalarArrayPtr & pv, std::size_t offset, std::size_t length,
|
||||
const uint16* from, std::size_t fromOffset)
|
||||
{ pv->putFrom<pvUShort>(from+fromOffset, length, offset); return length; }
|
||||
inline
|
||||
std::size_t fromUShortArray(
|
||||
PVScalarArrayPtr & pv, std::size_t offset, std::size_t length,
|
||||
const UShortArray & from, std::size_t fromOffset)
|
||||
{return fromUShortArray(pv, offset, length, &from[0], fromOffset);}
|
||||
/**
|
||||
* Convert a PV array from an uint array.
|
||||
* @param pv a PV
|
||||
* @param offset starting element in a PV
|
||||
* @param length number of elements to transfer
|
||||
* @param from value to put into PV
|
||||
* @param fromOffset starting element in the source array
|
||||
* @return number of elements converted
|
||||
* @throws std::invalid_argument if the element type is not numeric
|
||||
*/
|
||||
inline
|
||||
std::size_t fromUIntArray(
|
||||
PVScalarArrayPtr & pv, std::size_t offset, std::size_t length,
|
||||
const uint32* from, std::size_t fromOffset)
|
||||
{ pv->putFrom<pvUInt>(from+fromOffset, length, offset); return length; }
|
||||
inline
|
||||
std::size_t fromUIntArray(
|
||||
PVScalarArrayPtr & pv, std::size_t offset, std::size_t length,
|
||||
const UIntArray & from, std::size_t fromOffset)
|
||||
{return fromUIntArray(pv, offset, length, &from[0], fromOffset);}
|
||||
/**
|
||||
* Convert a PV array from a ulong array.
|
||||
* @param pv a PV
|
||||
* @param offset starting element in a PV
|
||||
* @param length number of elements to transfer
|
||||
* @param from value to put into PV
|
||||
* @param fromOffset starting element in the source array
|
||||
* @return number of elements converted
|
||||
* @throws std::invalid_argument if the element type is not numeric
|
||||
*/
|
||||
inline
|
||||
std::size_t fromULongArray(
|
||||
PVScalarArrayPtr & pv, std::size_t offset, std::size_t length,
|
||||
const uint64* from, std::size_t fromOffset)
|
||||
{ pv->putFrom<pvULong>(from+fromOffset, length, offset); return length; }
|
||||
inline
|
||||
std::size_t fromULongArray(
|
||||
PVScalarArrayPtr & pv, std::size_t offset, std::size_t length,
|
||||
const ULongArray & from, std::size_t fromOffset)
|
||||
{return fromULongArray(pv, offset, length, &from[0], fromOffset);}
|
||||
/**
|
||||
* Convert a PV array from a float array.
|
||||
* @param pv a PV
|
||||
* @param offset starting element in a PV
|
||||
* @param length number of elements to transfer
|
||||
* @param from value to put into PV
|
||||
* @param fromOffset starting element in the source array
|
||||
* @return number of elements converted
|
||||
* @throws std::invalid_argument if the element type is not numeric
|
||||
*/
|
||||
inline
|
||||
std::size_t fromFloatArray(
|
||||
PVScalarArrayPtr & pv, std::size_t offset, std::size_t length,
|
||||
const float* from, std::size_t fromOffset)
|
||||
{ pv->putFrom<pvFloat>(from+fromOffset, length, offset); return length; }
|
||||
inline
|
||||
std::size_t fromFloatArray(
|
||||
PVScalarArrayPtr & pv, std::size_t offset, std::size_t length,
|
||||
const FloatArray & from, std::size_t fromOffset)
|
||||
{return fromFloatArray(pv, offset, length, &from[0], fromOffset);}
|
||||
/**
|
||||
* Convert a PV array from a double array.
|
||||
* @param pv a PV
|
||||
* @param offset starting element in a PV
|
||||
* @param length number of elements to transfer
|
||||
* @param from value to put into PV
|
||||
* @param fromOffset starting element in the source array
|
||||
* @return number of elements converted
|
||||
* @throws std::invalid_argument if the element type is not numeric
|
||||
*/
|
||||
inline
|
||||
std::size_t fromDoubleArray(
|
||||
PVScalarArrayPtr & pv, std::size_t offset, std::size_t length,
|
||||
const double* from, std::size_t fromOffset)
|
||||
{ pv->putFrom<pvDouble>(from+fromOffset, length, offset); return length; }
|
||||
inline
|
||||
std::size_t fromDoubleArray(
|
||||
PVScalarArrayPtr & pv, std::size_t offset, std::size_t length,
|
||||
const DoubleArray & from, std::size_t fromOffset)
|
||||
{return fromDoubleArray(pv, offset, length, &from[0], fromOffset);}
|
||||
|
||||
/**
|
||||
* Convenience method for implementing toString.
|
||||
* It generates a newline and inserts blanks at the beginning of the newline.
|
||||
|
||||
@@ -392,365 +392,6 @@ static void testConvertScalar(FILE *fd) {
|
||||
fprintf(fd,"fromULong PASSED\n");
|
||||
}
|
||||
|
||||
static void testConvertScalarArray(FILE *fd) {
|
||||
PVScalarArrayPtr pvBytePtr = pvDataCreate->createPVScalarArray(pvByte);
|
||||
PVScalarArrayPtr pvUBytePtr = pvDataCreate->createPVScalarArray(pvUByte);
|
||||
PVScalarArrayPtr pvShortPtr = pvDataCreate->createPVScalarArray(pvShort);
|
||||
PVScalarArrayPtr pvUShortPtr = pvDataCreate->createPVScalarArray(pvUShort);
|
||||
PVScalarArrayPtr pvIntPtr = pvDataCreate->createPVScalarArray(pvInt);
|
||||
PVScalarArrayPtr pvUIntPtr = pvDataCreate->createPVScalarArray(pvUInt);
|
||||
PVScalarArrayPtr pvLongPtr = pvDataCreate->createPVScalarArray(pvLong);
|
||||
PVScalarArrayPtr pvULongPtr = pvDataCreate->createPVScalarArray(pvULong);
|
||||
PVScalarArrayPtr pvFloatPtr = pvDataCreate->createPVScalarArray(pvFloat);
|
||||
PVScalarArrayPtr pvDoublePtr = pvDataCreate->createPVScalarArray(pvDouble);
|
||||
|
||||
fprintf(fd,"testConvertScalarArray\n");
|
||||
if(debug) fprintf(fd,"\nfromByte\n");
|
||||
size_t length = 4;
|
||||
int8 barray[length];
|
||||
int8 bval = 127;
|
||||
barray[0] = bval;
|
||||
for(size_t i=1; i<length; i++) barray[i] = barray[i-1] + 1;
|
||||
convert->fromByteArray(pvBytePtr,0,length,barray,0);
|
||||
builder.clear(); pvBytePtr->toString(&builder);
|
||||
if(debug) fprintf(fd,"byte %s\n",builder.c_str());
|
||||
convert->fromByteArray(pvUBytePtr,0,length,barray,0);
|
||||
builder.clear(); pvUBytePtr->toString(&builder);
|
||||
if(debug) fprintf(fd,"ubyte %s\n",builder.c_str());
|
||||
convert->fromByteArray(pvShortPtr,0,length,barray,0);
|
||||
builder.clear(); pvShortPtr->toString(&builder);
|
||||
if(debug) fprintf(fd,"short %s\n",builder.c_str());
|
||||
convert->fromByteArray(pvUShortPtr,0,length,barray,0);
|
||||
builder.clear(); pvUShortPtr->toString(&builder);
|
||||
if(debug) fprintf(fd,"ushort %s\n",builder.c_str());
|
||||
convert->fromByteArray(pvIntPtr,0,length,barray,0);
|
||||
builder.clear(); pvIntPtr->toString(&builder);
|
||||
if(debug) fprintf(fd,"int %s\n",builder.c_str());
|
||||
convert->fromByteArray(pvUIntPtr,0,length,barray,0);
|
||||
builder.clear(); pvUIntPtr->toString(&builder);
|
||||
if(debug) fprintf(fd,"uint %s\n",builder.c_str());
|
||||
convert->fromByteArray(pvLongPtr,0,length,barray,0);
|
||||
builder.clear(); pvLongPtr->toString(&builder);
|
||||
if(debug) fprintf(fd,"long %s\n",builder.c_str());
|
||||
convert->fromByteArray(pvULongPtr,0,length,barray,0);
|
||||
builder.clear(); pvULongPtr->toString(&builder);
|
||||
if(debug) fprintf(fd,"ulong %s\n",builder.c_str());
|
||||
convert->fromByteArray(pvFloatPtr,0,length,barray,0);
|
||||
builder.clear(); pvFloatPtr->toString(&builder);
|
||||
if(debug) fprintf(fd,"float %s\n",builder.c_str());
|
||||
convert->fromByteArray(pvDoublePtr,0,length,barray,0);
|
||||
builder.clear(); pvDoublePtr->toString(&builder);
|
||||
if(debug) fprintf(fd,"double %s\n",builder.c_str());
|
||||
pvUBytePtr->assign(*pvFloatPtr.get());
|
||||
builder.clear(); pvFloatPtr->toString(&builder);
|
||||
if(debug) fprintf(fd,"float from unsigned %s\n",builder.c_str());
|
||||
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");
|
||||
|
||||
if(debug) fprintf(fd,"\nfromShort\n");
|
||||
int16 sarray[length];
|
||||
int16 sval = 0x7fff;
|
||||
sarray[0] = sval;
|
||||
for(size_t i=1; i<length; i++) sarray[i] = sarray[i-1] + 1;
|
||||
convert->fromShortArray(pvBytePtr,0,length,sarray,0);
|
||||
builder.clear(); pvBytePtr->toString(&builder);
|
||||
if(debug) fprintf(fd,"byte %s\n",builder.c_str());
|
||||
convert->fromShortArray(pvUBytePtr,0,length,sarray,0);
|
||||
builder.clear(); pvUBytePtr->toString(&builder);
|
||||
if(debug) fprintf(fd,"ubyte %s\n",builder.c_str());
|
||||
convert->fromShortArray(pvShortPtr,0,length,sarray,0);
|
||||
builder.clear(); pvShortPtr->toString(&builder);
|
||||
if(debug) fprintf(fd,"short %s\n",builder.c_str());
|
||||
convert->fromShortArray(pvUShortPtr,0,length,sarray,0);
|
||||
builder.clear(); pvUShortPtr->toString(&builder);
|
||||
if(debug) fprintf(fd,"ushort %s\n",builder.c_str());
|
||||
convert->fromShortArray(pvIntPtr,0,length,sarray,0);
|
||||
builder.clear(); pvIntPtr->toString(&builder);
|
||||
if(debug) fprintf(fd,"int %s\n",builder.c_str());
|
||||
convert->fromShortArray(pvUIntPtr,0,length,sarray,0);
|
||||
builder.clear(); pvUIntPtr->toString(&builder);
|
||||
if(debug) fprintf(fd,"uint %s\n",builder.c_str());
|
||||
convert->fromShortArray(pvLongPtr,0,length,sarray,0);
|
||||
builder.clear(); pvLongPtr->toString(&builder);
|
||||
if(debug) fprintf(fd,"long %s\n",builder.c_str());
|
||||
convert->fromShortArray(pvULongPtr,0,length,sarray,0);
|
||||
builder.clear(); pvULongPtr->toString(&builder);
|
||||
if(debug) fprintf(fd,"ulong %s\n",builder.c_str());
|
||||
convert->fromShortArray(pvFloatPtr,0,length,sarray,0);
|
||||
builder.clear(); pvFloatPtr->toString(&builder);
|
||||
if(debug) fprintf(fd,"float %s\n",builder.c_str());
|
||||
convert->fromShortArray(pvDoublePtr,0,length,sarray,0);
|
||||
builder.clear(); pvDoublePtr->toString(&builder);
|
||||
if(debug) fprintf(fd,"double %s\n",builder.c_str());
|
||||
pvUShortPtr->assign(*pvFloatPtr.get());
|
||||
builder.clear(); pvFloatPtr->toString(&builder);
|
||||
if(debug) fprintf(fd,"float from unsigned %s\n",builder.c_str());
|
||||
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");
|
||||
|
||||
if(debug) fprintf(fd,"\nfromInt\n");
|
||||
int32 iarray[length];
|
||||
int32 ival = 0x7fffffff;
|
||||
iarray[0] = ival;
|
||||
for(size_t i=1; i<length; i++) iarray[i] = iarray[i-1] + 1;
|
||||
convert->fromIntArray(pvBytePtr,0,length,iarray,0);
|
||||
builder.clear(); pvBytePtr->toString(&builder);
|
||||
if(debug) fprintf(fd,"byte %s\n",builder.c_str());
|
||||
convert->fromIntArray(pvUBytePtr,0,length,iarray,0);
|
||||
builder.clear(); pvUBytePtr->toString(&builder);
|
||||
if(debug) fprintf(fd,"ubyte %s\n",builder.c_str());
|
||||
convert->fromIntArray(pvShortPtr,0,length,iarray,0);
|
||||
builder.clear(); pvShortPtr->toString(&builder);
|
||||
if(debug) fprintf(fd,"short %s\n",builder.c_str());
|
||||
convert->fromIntArray(pvUShortPtr,0,length,iarray,0);
|
||||
builder.clear(); pvUShortPtr->toString(&builder);
|
||||
if(debug) fprintf(fd,"ushort %s\n",builder.c_str());
|
||||
convert->fromIntArray(pvIntPtr,0,length,iarray,0);
|
||||
builder.clear(); pvIntPtr->toString(&builder);
|
||||
if(debug) fprintf(fd,"int %s\n",builder.c_str());
|
||||
convert->fromIntArray(pvUIntPtr,0,length,iarray,0);
|
||||
builder.clear(); pvUIntPtr->toString(&builder);
|
||||
if(debug) fprintf(fd,"uint %s\n",builder.c_str());
|
||||
convert->fromIntArray(pvLongPtr,0,length,iarray,0);
|
||||
builder.clear(); pvLongPtr->toString(&builder);
|
||||
if(debug) fprintf(fd,"long %s\n",builder.c_str());
|
||||
convert->fromIntArray(pvULongPtr,0,length,iarray,0);
|
||||
builder.clear(); pvULongPtr->toString(&builder);
|
||||
if(debug) fprintf(fd,"ulong %s\n",builder.c_str());
|
||||
convert->fromIntArray(pvFloatPtr,0,length,iarray,0);
|
||||
builder.clear(); pvFloatPtr->toString(&builder);
|
||||
if(debug) fprintf(fd,"float %s\n",builder.c_str());
|
||||
convert->fromIntArray(pvDoublePtr,0,length,iarray,0);
|
||||
builder.clear(); pvDoublePtr->toString(&builder);
|
||||
if(debug) fprintf(fd,"double %s\n",builder.c_str());
|
||||
pvUIntPtr->assign(*pvFloatPtr.get());
|
||||
builder.clear(); pvFloatPtr->toString(&builder);
|
||||
if(debug) fprintf(fd,"float from unsigned %s\n",builder.c_str());
|
||||
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");
|
||||
|
||||
if(debug) fprintf(fd,"\nfromLong\n");
|
||||
int64 larray[length];
|
||||
int64 lval = 0x7fffffffffffffffLL;
|
||||
larray[0] = lval;
|
||||
for(size_t i=1; i<length; i++) larray[i] = larray[i-1] + 1;
|
||||
convert->fromLongArray(pvBytePtr,0,length,larray,0);
|
||||
builder.clear(); pvBytePtr->toString(&builder);
|
||||
if(debug) fprintf(fd,"byte %s\n",builder.c_str());
|
||||
convert->fromLongArray(pvUBytePtr,0,length,larray,0);
|
||||
builder.clear(); pvUBytePtr->toString(&builder);
|
||||
if(debug) fprintf(fd,"ubyte %s\n",builder.c_str());
|
||||
convert->fromLongArray(pvShortPtr,0,length,larray,0);
|
||||
builder.clear(); pvShortPtr->toString(&builder);
|
||||
if(debug) fprintf(fd,"short %s\n",builder.c_str());
|
||||
convert->fromLongArray(pvUShortPtr,0,length,larray,0);
|
||||
builder.clear(); pvUShortPtr->toString(&builder);
|
||||
if(debug) fprintf(fd,"ushort %s\n",builder.c_str());
|
||||
convert->fromLongArray(pvIntPtr,0,length,larray,0);
|
||||
builder.clear(); pvIntPtr->toString(&builder);
|
||||
if(debug) fprintf(fd,"int %s\n",builder.c_str());
|
||||
convert->fromLongArray(pvUIntPtr,0,length,larray,0);
|
||||
builder.clear(); pvUIntPtr->toString(&builder);
|
||||
if(debug) fprintf(fd,"uint %s\n",builder.c_str());
|
||||
convert->fromLongArray(pvLongPtr,0,length,larray,0);
|
||||
builder.clear(); pvLongPtr->toString(&builder);
|
||||
if(debug) fprintf(fd,"long %s\n",builder.c_str());
|
||||
convert->fromLongArray(pvULongPtr,0,length,larray,0);
|
||||
builder.clear(); pvULongPtr->toString(&builder);
|
||||
if(debug) fprintf(fd,"ulong %s\n",builder.c_str());
|
||||
convert->fromLongArray(pvFloatPtr,0,length,larray,0);
|
||||
builder.clear(); pvFloatPtr->toString(&builder);
|
||||
if(debug) fprintf(fd,"float %s\n",builder.c_str());
|
||||
convert->fromLongArray(pvDoublePtr,0,length,larray,0);
|
||||
builder.clear(); pvDoublePtr->toString(&builder);
|
||||
if(debug) fprintf(fd,"double %s\n",builder.c_str());
|
||||
pvULongPtr->assign(*pvFloatPtr.get());
|
||||
builder.clear(); pvFloatPtr->toString(&builder);
|
||||
if(debug) fprintf(fd,"float from unsigned %s\n",builder.c_str());
|
||||
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");
|
||||
|
||||
if(debug) fprintf(fd,"\nfromUByte\n");
|
||||
uint8 ubarray[length];
|
||||
uint8 ubval = 127;
|
||||
ubarray[0] = ubval;
|
||||
for(size_t i=1; i<length; i++) ubarray[i] = ubarray[i-1] + 1;
|
||||
convert->fromUByteArray(pvBytePtr,0,length,ubarray,0);
|
||||
builder.clear(); pvBytePtr->toString(&builder);
|
||||
if(debug) fprintf(fd,"byte %s\n",builder.c_str());
|
||||
convert->fromUByteArray(pvUBytePtr,0,length,ubarray,0);
|
||||
builder.clear(); pvUBytePtr->toString(&builder);
|
||||
if(debug) fprintf(fd,"ubyte %s\n",builder.c_str());
|
||||
convert->fromUByteArray(pvShortPtr,0,length,ubarray,0);
|
||||
builder.clear(); pvShortPtr->toString(&builder);
|
||||
if(debug) fprintf(fd,"short %s\n",builder.c_str());
|
||||
convert->fromUByteArray(pvUShortPtr,0,length,ubarray,0);
|
||||
builder.clear(); pvUShortPtr->toString(&builder);
|
||||
if(debug) fprintf(fd,"ushort %s\n",builder.c_str());
|
||||
convert->fromUByteArray(pvIntPtr,0,length,ubarray,0);
|
||||
builder.clear(); pvIntPtr->toString(&builder);
|
||||
if(debug) fprintf(fd,"int %s\n",builder.c_str());
|
||||
convert->fromUByteArray(pvUIntPtr,0,length,ubarray,0);
|
||||
builder.clear(); pvUIntPtr->toString(&builder);
|
||||
if(debug) fprintf(fd,"uint %s\n",builder.c_str());
|
||||
convert->fromUByteArray(pvLongPtr,0,length,ubarray,0);
|
||||
builder.clear(); pvLongPtr->toString(&builder);
|
||||
if(debug) fprintf(fd,"long %s\n",builder.c_str());
|
||||
convert->fromUByteArray(pvULongPtr,0,length,ubarray,0);
|
||||
builder.clear(); pvULongPtr->toString(&builder);
|
||||
if(debug) fprintf(fd,"ulong %s\n",builder.c_str());
|
||||
convert->fromUByteArray(pvFloatPtr,0,length,ubarray,0);
|
||||
builder.clear(); pvFloatPtr->toString(&builder);
|
||||
if(debug) fprintf(fd,"float %s\n",builder.c_str());
|
||||
convert->fromUByteArray(pvDoublePtr,0,length,ubarray,0);
|
||||
builder.clear(); pvDoublePtr->toString(&builder);
|
||||
if(debug) fprintf(fd,"double %s\n",builder.c_str());
|
||||
pvUBytePtr->assign(*pvFloatPtr.get());
|
||||
builder.clear(); pvFloatPtr->toString(&builder);
|
||||
if(debug) fprintf(fd,"float from unsigned %s\n",builder.c_str());
|
||||
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");
|
||||
|
||||
if(debug) fprintf(fd,"\nfromUShort\n");
|
||||
uint16 usarray[length];
|
||||
uint16 usval = 0x7fff;
|
||||
usarray[0] = usval;
|
||||
for(size_t i=1; i<length; i++) usarray[i] = usarray[i-1] + 1;
|
||||
convert->fromUShortArray(pvBytePtr,0,length,usarray,0);
|
||||
builder.clear(); pvBytePtr->toString(&builder);
|
||||
if(debug) fprintf(fd,"byte %s\n",builder.c_str());
|
||||
convert->fromUShortArray(pvUBytePtr,0,length,usarray,0);
|
||||
builder.clear(); pvUBytePtr->toString(&builder);
|
||||
if(debug) fprintf(fd,"ubyte %s\n",builder.c_str());
|
||||
convert->fromUShortArray(pvShortPtr,0,length,usarray,0);
|
||||
builder.clear(); pvShortPtr->toString(&builder);
|
||||
if(debug) fprintf(fd,"short %s\n",builder.c_str());
|
||||
convert->fromUShortArray(pvUShortPtr,0,length,usarray,0);
|
||||
builder.clear(); pvUShortPtr->toString(&builder);
|
||||
if(debug) fprintf(fd,"ushort %s\n",builder.c_str());
|
||||
convert->fromUShortArray(pvIntPtr,0,length,usarray,0);
|
||||
builder.clear(); pvIntPtr->toString(&builder);
|
||||
if(debug) fprintf(fd,"int %s\n",builder.c_str());
|
||||
convert->fromUShortArray(pvUIntPtr,0,length,usarray,0);
|
||||
builder.clear(); pvUIntPtr->toString(&builder);
|
||||
if(debug) fprintf(fd,"uint %s\n",builder.c_str());
|
||||
convert->fromUShortArray(pvLongPtr,0,length,usarray,0);
|
||||
builder.clear(); pvLongPtr->toString(&builder);
|
||||
if(debug) fprintf(fd,"long %s\n",builder.c_str());
|
||||
convert->fromUShortArray(pvULongPtr,0,length,usarray,0);
|
||||
builder.clear(); pvULongPtr->toString(&builder);
|
||||
if(debug) fprintf(fd,"ulong %s\n",builder.c_str());
|
||||
convert->fromUShortArray(pvFloatPtr,0,length,usarray,0);
|
||||
builder.clear(); pvFloatPtr->toString(&builder);
|
||||
if(debug) fprintf(fd,"float %s\n",builder.c_str());
|
||||
convert->fromUShortArray(pvDoublePtr,0,length,usarray,0);
|
||||
builder.clear(); pvDoublePtr->toString(&builder);
|
||||
if(debug) fprintf(fd,"double %s\n",builder.c_str());
|
||||
pvUShortPtr->assign(*pvFloatPtr.get());
|
||||
builder.clear(); pvFloatPtr->toString(&builder);
|
||||
if(debug) fprintf(fd,"float from unsigned %s\n",builder.c_str());
|
||||
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");
|
||||
|
||||
if(debug) fprintf(fd,"\nfromUInt\n");
|
||||
uint32 uiarray[length];
|
||||
uint32 uival = 0x7fffffff;
|
||||
uiarray[0] = uival;
|
||||
for(size_t i=1; i<length; i++) uiarray[i] = uiarray[i-1] + 1;
|
||||
convert->fromUIntArray(pvBytePtr,0,length,uiarray,0);
|
||||
builder.clear(); pvBytePtr->toString(&builder);
|
||||
if(debug) fprintf(fd,"byte %s\n",builder.c_str());
|
||||
convert->fromUIntArray(pvUBytePtr,0,length,uiarray,0);
|
||||
builder.clear(); pvUBytePtr->toString(&builder);
|
||||
if(debug) fprintf(fd,"ubyte %s\n",builder.c_str());
|
||||
convert->fromUIntArray(pvShortPtr,0,length,uiarray,0);
|
||||
builder.clear(); pvShortPtr->toString(&builder);
|
||||
if(debug) fprintf(fd,"short %s\n",builder.c_str());
|
||||
convert->fromUIntArray(pvUShortPtr,0,length,uiarray,0);
|
||||
builder.clear(); pvUShortPtr->toString(&builder);
|
||||
if(debug) fprintf(fd,"ushort %s\n",builder.c_str());
|
||||
convert->fromUIntArray(pvIntPtr,0,length,uiarray,0);
|
||||
builder.clear(); pvIntPtr->toString(&builder);
|
||||
if(debug) fprintf(fd,"int %s\n",builder.c_str());
|
||||
convert->fromUIntArray(pvUIntPtr,0,length,uiarray,0);
|
||||
builder.clear(); pvUIntPtr->toString(&builder);
|
||||
if(debug) fprintf(fd,"uint %s\n",builder.c_str());
|
||||
convert->fromUIntArray(pvLongPtr,0,length,uiarray,0);
|
||||
builder.clear(); pvLongPtr->toString(&builder);
|
||||
if(debug) fprintf(fd,"long %s\n",builder.c_str());
|
||||
convert->fromUIntArray(pvULongPtr,0,length,uiarray,0);
|
||||
builder.clear(); pvULongPtr->toString(&builder);
|
||||
if(debug) fprintf(fd,"ulong %s\n",builder.c_str());
|
||||
convert->fromUIntArray(pvFloatPtr,0,length,uiarray,0);
|
||||
builder.clear(); pvFloatPtr->toString(&builder);
|
||||
if(debug) fprintf(fd,"float %s\n",builder.c_str());
|
||||
convert->fromUIntArray(pvDoublePtr,0,length,uiarray,0);
|
||||
builder.clear(); pvDoublePtr->toString(&builder);
|
||||
if(debug) fprintf(fd,"double %s\n",builder.c_str());
|
||||
pvUIntPtr->assign(*pvFloatPtr.get());
|
||||
builder.clear(); pvFloatPtr->toString(&builder);
|
||||
if(debug) fprintf(fd,"float from unsigned %s\n",builder.c_str());
|
||||
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");
|
||||
|
||||
if(debug) fprintf(fd,"\nfromULong\n");
|
||||
uint64 ularray[length];
|
||||
uint64 ulval = 0x7fffffffffffffffLL;
|
||||
ularray[0] = ulval;
|
||||
for(size_t i=1; i<length; i++) ularray[i] = ularray[i-1] + 1;
|
||||
convert->fromULongArray(pvBytePtr,0,length,ularray,0);
|
||||
builder.clear(); pvBytePtr->toString(&builder);
|
||||
if(debug) fprintf(fd,"byte %s\n",builder.c_str());
|
||||
convert->fromULongArray(pvUBytePtr,0,length,ularray,0);
|
||||
builder.clear(); pvUBytePtr->toString(&builder);
|
||||
if(debug) fprintf(fd,"ubyte %s\n",builder.c_str());
|
||||
convert->fromULongArray(pvShortPtr,0,length,ularray,0);
|
||||
builder.clear(); pvShortPtr->toString(&builder);
|
||||
if(debug) fprintf(fd,"short %s\n",builder.c_str());
|
||||
convert->fromULongArray(pvUShortPtr,0,length,ularray,0);
|
||||
builder.clear(); pvUShortPtr->toString(&builder);
|
||||
if(debug) fprintf(fd,"ushort %s\n",builder.c_str());
|
||||
convert->fromULongArray(pvIntPtr,0,length,ularray,0);
|
||||
builder.clear(); pvIntPtr->toString(&builder);
|
||||
if(debug) fprintf(fd,"int %s\n",builder.c_str());
|
||||
convert->fromULongArray(pvUIntPtr,0,length,ularray,0);
|
||||
builder.clear(); pvUIntPtr->toString(&builder);
|
||||
if(debug) fprintf(fd,"uint %s\n",builder.c_str());
|
||||
convert->fromULongArray(pvLongPtr,0,length,ularray,0);
|
||||
builder.clear(); pvLongPtr->toString(&builder);
|
||||
if(debug) fprintf(fd,"long %s\n",builder.c_str());
|
||||
convert->fromULongArray(pvULongPtr,0,length,ularray,0);
|
||||
builder.clear(); pvULongPtr->toString(&builder);
|
||||
if(debug) fprintf(fd,"ulong %s\n",builder.c_str());
|
||||
convert->fromULongArray(pvFloatPtr,0,length,ularray,0);
|
||||
builder.clear(); pvFloatPtr->toString(&builder);
|
||||
if(debug) fprintf(fd,"float %s\n",builder.c_str());
|
||||
convert->fromULongArray(pvDoublePtr,0,length,ularray,0);
|
||||
builder.clear(); pvDoublePtr->toString(&builder);
|
||||
if(debug) fprintf(fd,"double %s\n",builder.c_str());
|
||||
pvULongPtr->assign(*pvFloatPtr.get());
|
||||
builder.clear(); pvFloatPtr->toString(&builder);
|
||||
if(debug) fprintf(fd,"float from unsigned %s\n",builder.c_str());
|
||||
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");
|
||||
}
|
||||
|
||||
int main(int argc,char *argv[])
|
||||
{
|
||||
char *fileName = 0;
|
||||
@@ -765,7 +406,6 @@ int main(int argc,char *argv[])
|
||||
standardPVField = getStandardPVField();
|
||||
convert = getConvert();
|
||||
testConvertScalar(fd);
|
||||
testConvertScalarArray(fd);
|
||||
fprintf(fd,"THIS NEEDS MANY MORE TESTS AND ASSERTS\n");
|
||||
return(0);
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user