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

lots of work on Scalar Arrays

Browse Source
This commit is contained in:
Marty Kraimer
2012-05-21 10:06:28 -04:00
parent 8040ad5fc7
commit e9b0dcd9f4
10 changed files with 588 additions and 106 deletions
Download Patch File Download Diff File Expand all files Collapse all files

138
pvDataApp/factory/Convert.cpp
View File

@@ -15,7 +15,6 @@
#include <pv/convert.h>
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<typename PVT,typename T>
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<PVByteArray,int8>(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<PVShortArray,int16>(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<PVIntArray,int32>(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<PVLongArray,int64>(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<PVUByteArray,uint8>(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<PVUShortArray,uint16>(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<PVUIntArray,uint32>(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<PVULongArray,uint64>(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<PVFloatArray,float>(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<PVDoubleArray,double>(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<PVStringArray*>(pv);
while (len > 0) {
size_t n = pvdata->put(offset, len, get(from), fromOffset);
String * xxx = const_cast<String *>(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<String *>(&xxx[0]);
String *to = &xxx[0];
ScalarType elementType = pv->getScalarArray()->getElementType();
size_t ncopy = pv->getLength();
if (ncopy > len) ncopy = len;

7
pvDataApp/factory/PVDataCreateFactory.cpp
View File

@@ -19,7 +19,6 @@
#include <pv/serializeHelper.h>
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<typename T>
class DefaultPVArray : public PVValueArray<T> {
public:
typedef T* pointer;
typedef const T* const_pointer;
typedef std::vector<T> vector;
typedef const std::vector<T> const_vector;
typedef std::tr1::shared_ptr<vector> 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<T> &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<std::vector<T> > const & value,
@@ -245,7 +246,7 @@ size_t DefaultPVArray<T>::get(size_t offset, size_t len, PVArrayData<T> &data)
template<typename T>
size_t DefaultPVArray<T>::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);

1
pvDataApp/factory/PVStructure.cpp
View File

@@ -16,7 +16,6 @@
#include <pv/bitSet.h>
using std::tr1::static_pointer_cast;
using std::tr1::const_pointer_cast;
using std::size_t;
namespace epics { namespace pvData {

1
pvDataApp/factory/PVStructureArray.cpp
View File

@@ -14,7 +14,6 @@
#include <pv/serializeHelper.h>
using std::tr1::static_pointer_cast;
using std::tr1::const_pointer_cast;
using std::size_t;
namespace epics { namespace pvData {

82
pvDataApp/pv/convert.h
View File

@@ -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.

19
pvDataApp/pv/pvData.h
View File

@@ -329,7 +329,7 @@ private:
/**
* typedefs for the various possible scalar types.
*/
typedef PVScalarValue<boolean> PVBoolean;
typedef PVScalarValue<uint8> PVBoolean;
typedef PVScalarValue<int8> PVByte;
typedef PVScalarValue<int16> PVShort;
typedef PVScalarValue<int32> PVInt;
@@ -770,6 +770,7 @@ public:
typedef const T* const_pointer;
typedef PVArrayData<T> ArrayDataType;
typedef std::vector<T> vector;
typedef const std::vector<T> const_vector;
typedef std::tr1::shared_ptr<vector> 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<typename T>
std::size_t PVValueArray<T>::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<boolean> BooleanArrayData;
typedef PVValueArray<boolean> PVBooleanArray;
typedef PVArrayData<uint8> BooleanArrayData;
typedef PVValueArray<uint8> PVBooleanArray;
typedef std::tr1::shared_ptr<PVBooleanArray> PVBooleanArrayPtr;
typedef PVArrayData<int8> ByteArrayData;

98
pvDataApp/pv/pvType.h
View File

@@ -69,23 +69,21 @@ typedef std::string String;
/**
* A boolean array.
*/
typedef std::vector<boolean> BooleanArray;
// get will be the same as for UByte
/*
inline boolean * get(BooleanArray value)
{
return const_cast<boolean *>(&value[0]);
}
*/
typedef std::vector<uint8> BooleanArray;
/* get is same is UInt */
typedef std::vector<uint8>::iterator BooleanArray_iterator;
typedef std::vector<uint8>::const_iterator BooleanArray_const_iterator;
/**
* A byte array.
*/
typedef std::vector<int8> ByteArray;
inline int8 * get(ByteArray value)
inline int8 * get(ByteArray &value)
{
return const_cast<int8 *>(&value[0]);
return &value[0];
}
inline const int8 * get(const ByteArray &value)
{
return static_cast<const int8 *>(&value[0]);
}
typedef std::vector<int8>::iterator ByteArray_iterator;
typedef std::vector<int8>::const_iterator ByteArray_const_iterator;
@@ -93,9 +91,13 @@ typedef std::vector<int8>::const_iterator ByteArray_const_iterator;
* A short array.
*/
typedef std::vector<int16> ShortArray;
inline int16 * get(ShortArray value)
inline int16 * get(ShortArray &value)
{
return const_cast<int16 *>(&value[0]);
return &value[0];
}
inline const int16 * get(const ShortArray &value)
{
return static_cast<const int16 *>(&value[0]);
}
typedef std::vector<int16>::iterator ShortArray_iterator;
typedef std::vector<int16>::const_iterator ShortArray_const_iterator;
@@ -103,9 +105,13 @@ typedef std::vector<int16>::const_iterator ShortArray_const_iterator;
* A int array.
*/
typedef std::vector<int32> IntArray;
inline int32 * get(IntArray value)
inline int32 * get(IntArray &value)
{
return const_cast<int32 *>(&value[0]);
return &value[0];
}
inline const int32 * get(const IntArray &value)
{
return static_cast<const int32 *>(&value[0]);
}
typedef std::vector<int32>::iterator IntArray_iterator;
typedef std::vector<int32>::const_iterator IntArray_const_iterator;
@@ -113,9 +119,13 @@ typedef std::vector<int32>::const_iterator IntArray_const_iterator;
* A long array.
*/
typedef std::vector<int64> LongArray;
inline int64 * get(LongArray value)
inline int64 * get(LongArray &value)
{
return const_cast<int64 *>(&value[0]);
return &value[0];
}
inline const int64 * get(const LongArray &value)
{
return static_cast<const int64 *>(&value[0]);
}
typedef std::vector<int64>::iterator LongArray_iterator;
typedef std::vector<int64>::const_iterator LongArray_const_iterator;
@@ -123,9 +133,13 @@ typedef std::vector<int64>::const_iterator LongArray_const_iterator;
* An unsigned byte array.
*/
typedef std::vector<uint8> UByteArray;
inline uint8 * get(UByteArray value)
inline uint8 * get(UByteArray &value)
{
return const_cast<uint8 *>(&value[0]);
return &value[0];
}
inline const uint8 * get(const UByteArray &value)
{
return static_cast<const uint8 *>(&value[0]);
}
typedef std::vector<uint8>::iterator UByteArray_iterator;
typedef std::vector<uint8>::const_iterator UByteArray_const_iterator;
@@ -133,9 +147,13 @@ typedef std::vector<uint8>::const_iterator UByteArray_const_iterator;
* An unsigned short array.
*/
typedef std::vector<uint16> UShortArray;
inline uint16 * get(UShortArray value)
inline uint16 * get(UShortArray &value)
{
return const_cast<uint16 *>(&value[0]);
return &value[0];
}
inline const uint16 * get(const UShortArray &value)
{
return static_cast<const uint16 *>(&value[0]);
}
typedef std::vector<uint16>::iterator UShortArray_iterator;
typedef std::vector<uint16>::const_iterator UShortArray_const_iterator;
@@ -143,9 +161,13 @@ typedef std::vector<uint16>::const_iterator UShortArray_const_iterator;
* An unsigned int array.
*/
typedef std::vector<uint32> UIntArray;
inline uint32 * get(UIntArray value)
inline uint32 * get(UIntArray &value)
{
return const_cast<uint32 *>(&value[0]);
return &value[0];
}
inline const uint32 * get(const UIntArray &value)
{
return static_cast<const uint32 *>(&value[0]);
}
typedef std::vector<uint32>::iterator UIntArray_iterator;
typedef std::vector<uint32>::const_iterator UIntArray_const_iterator;
@@ -153,9 +175,13 @@ typedef std::vector<uint32>::const_iterator UIntArray_const_iterator;
* An unsigned long array.
*/
typedef std::vector<uint64> ULongArray;
inline uint64 * get(ULongArray value)
inline uint64 * get(ULongArray &value)
{
return const_cast<uint64 *>(&value[0]);
return &value[0];
}
inline const uint64 * get(const ULongArray &value)
{
return static_cast<const uint64 *>(&value[0]);
}
typedef std::vector<uint64>::iterator ULongArray_iterator;
typedef std::vector<uint64>::const_iterator ULongArray_const_iterator;
@@ -163,9 +189,13 @@ typedef std::vector<uint64>::const_iterator ULongArray_const_iterator;
* A float array.
*/
typedef std::vector<float> FloatArray;
inline float * get(FloatArray value)
inline float * get(FloatArray &value)
{
return const_cast<float *>(&value[0]);
return &value[0];
}
inline const float * get(const FloatArray &value)
{
return static_cast<const float *>(&value[0]);
}
typedef std::vector<float>::iterator FloatArray_iterator;
typedef std::vector<float>::const_iterator FloatArray_const_iterator;
@@ -173,9 +203,13 @@ typedef std::vector<float>::const_iterator FloatArray_const_iterator;
* A double array.
*/
typedef std::vector<double> DoubleArray;
inline double * get(DoubleArray value)
inline double * get(DoubleArray &value)
{
return const_cast<double *>(&value[0]);
return &value[0];
}
inline const double * get(const DoubleArray &value)
{
return static_cast<const double *>(&value[0]);
}
typedef std::vector<double>::iterator DoubleArray_iterator;
typedef std::vector<double>::const_iterator DoubleArray_const_iterator;
@@ -183,9 +217,13 @@ typedef std::vector<double>::const_iterator DoubleArray_const_iterator;
* A string array.
*/
typedef std::vector<String> StringArray;
inline String * get(StringArray value)
inline String * get(StringArray &value)
{
return const_cast<String *>(&value[0]);
return &value[0];
}
inline const String * get(const StringArray &value)
{
return static_cast<const String *>(&value[0]);
}
typedef std::vector<String>::iterator StringArray_iterator;
typedef std::vector<String>::const_iterator StringArray_const_iterator;

4
testApp/pv/Makefile
View File

@@ -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

7
testApp/pv/testConvert.cpp
View File

@@ -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<PVULongArray>(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[])

337
testApp/pv/testPVScalarArray.cpp Normal file
View File

@@ -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 <cstddef>
#include <cstdlib>
#include <cstddef>
#include <string>
#include <cstdio>
#include <epicsAssert.h>
#include <epicsExit.h>
#include <pv/requester.h>
#include <pv/pvIntrospect.h>
#include <pv/pvData.h>
#include <pv/convert.h>
#include <pv/standardField.h>
#include <pv/standardPVField.h>
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<PVByteArray>(pvScalarArray);
ByteArray value;
value.reserve(length);
int8 xxx = 0x7f;
for(size_t i = 0; i<length; i++) value.push_back(xxx++);
pvByteArray->put(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; i<length; i++) {
int val = pdata[i];
fprintf(fd,"%d ",val);
}
fprintf(fd,"]\n");
fprintf(fd,"direct[");
for(size_t i=0; i<length; i++) {
int val = data.data[i];
fprintf(fd,"%d ",val);
}
fprintf(fd,"]\n");
}
static void ubyteArray()
{
PVScalarArrayPtr pvScalarArray = pvDataCreate->createPVScalarArray(pvUByte);;
PVUByteArrayPtr pvUByteArray = static_pointer_cast<PVUByteArray>(pvScalarArray);
UByteArray value;
value.reserve(length);
uint8 xxx = 0x7f;
for(size_t i = 0; i<length; i++) value.push_back(xxx++);
pvUByteArray->put(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; i<length; i++) {
unsigned int val = pdata[i];
fprintf(fd,"%d ",val);
}
fprintf(fd,"]\n");
fprintf(fd,"direct[");
for(size_t i=0; i<length; i++) {
unsigned int val = data.data[i];
fprintf(fd,"%d ",val);
}
fprintf(fd,"]\n");
}
static void longArray()
{
PVScalarArrayPtr pvScalarArray = pvDataCreate->createPVScalarArray(pvLong);;
PVLongArrayPtr pvLongArray = static_pointer_cast<PVLongArray>(pvScalarArray);
LongArray value;
value.reserve(length);
int64 xxx = 0x7fffffffffffffffL;
for(size_t i = 0; i<length; i++) value.push_back(xxx++);
pvLongArray->put(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; i<length; i++) {
int64 val = pdata[i];
fprintf(fd,"%lli ",val);
}
fprintf(fd,"]\n");
fprintf(fd,"direct[");
for(size_t i=0; i<length; i++) {
int64 val = data.data[i];
fprintf(fd,"%lli ",val);
}
fprintf(fd,"]\n");
}
static void ulongArray()
{
PVScalarArrayPtr pvScalarArray = pvDataCreate->createPVScalarArray(pvULong);;
PVULongArrayPtr pvULongArray = static_pointer_cast<PVULongArray>(pvScalarArray);
ULongArray value;
value.reserve(length);
uint64 xxx = 0x7fffffffffffffffL;
for(size_t i = 0; i<length; i++) value.push_back(xxx++);
pvULongArray->put(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; i<length; i++) {
uint64 val = pdata[i];
fprintf(fd,"%llu ",val);
}
fprintf(fd,"]\n");
fprintf(fd,"direct[");
for(size_t i=0; i<length; i++) {
uint64 val = data.data[i];
fprintf(fd,"%llu ",val);
}
fprintf(fd,"]\n");
}
static void floatArray()
{
PVScalarArrayPtr pvScalarArray = pvDataCreate->createPVScalarArray(pvFloat);;
PVFloatArrayPtr pvFloatArray = static_pointer_cast<PVFloatArray>(pvScalarArray);
FloatArray value;
value.reserve(length);
for(size_t i = 0; i<length; i++) value.push_back(10.0*i);
pvFloatArray->put(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; i<length; i++) {
float val = pdata[i];
fprintf(fd,"%f ",val);
}
fprintf(fd,"]\n");
fprintf(fd,"direct[");
for(size_t i=0; i<length; i++) {
float val = data.data[i];
fprintf(fd,"%f ",val);
}
fprintf(fd,"]\n");
}
static void doubleArray()
{
PVScalarArrayPtr pvScalarArray = pvDataCreate->createPVScalarArray(pvDouble);;
PVDoubleArrayPtr pvDoubleArray = static_pointer_cast<PVDoubleArray>(pvScalarArray);
DoubleArray value;
value.reserve(length);
for(size_t i = 0; i<length; i++) value.push_back(10.0*i);
pvDoubleArray->put(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; i<length; i++) {
double val = pdata[i];
fprintf(fd,"%lf ",val);
}
fprintf(fd,"]\n");
fprintf(fd,"direct[");
for(size_t i=0; i<length; i++) {
double val = data.data[i];
fprintf(fd,"%lf ",val);
}
fprintf(fd,"]\n");
}
static void stringArray()
{
PVScalarArrayPtr pvScalarArray = pvDataCreate->createPVScalarArray(pvString);;
PVStringArrayPtr pvStringArray = static_pointer_cast<PVStringArray>(pvScalarArray);
StringArray value;
value.reserve(length);
for(int i = 0; i<length; i++) {
char val[20];
sprintf(val,"value%d",i);
value.push_back(val);
}
pvStringArray->put(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; i<length; i++) {
String val = pdata[i];
fprintf(fd,"%s ",val.c_str());
}
fprintf(fd,"]\n");
fprintf(fd,"direct[");
for(size_t i=0; i<length; i++) {
String val = data.data[i];
fprintf(fd,"%s ",val.c_str());
}
fprintf(fd,"]\n");
}
int main(int argc,char *argv[])
{
char *fileName = 0;
if(argc>1) 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);
}