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

replace vector to/from in Convert

Browse Source
This commit is contained in:
Michael Davidsaver
2013-04-30 14:41:29 -04:00
parent a7fde21300
commit 659ce13e98
2 changed files with 92 additions and 749 deletions
Download Patch File Download Diff File Expand all files Collapse all files
pvDataApp/factory/Convert.cpp
+2 -719
View File
@@ -24,56 +24,6 @@ using std::size_t;
namespace epics { namespace pvData {
static void newLineImpl(StringBuilder buffer, int indentLevel)
{
*buffer += "\n";
for(int i=0; i<indentLevel; i++) *buffer += " ";
}
static size_t convertFromByteArray(PVScalarArray * pv, size_t offset,
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,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,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,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,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,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,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,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,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,const double from[], size_t fromOffset);
static size_t convertToDoubleArray(PVScalarArray *pv, size_t offset,
size_t len,double to[], size_t toOffset);
static std::vector<String> split(String commaSeparatedList);
static std::vector<String> split(String commaSeparatedList) {
String::size_type numValues = 1;
String::size_type index=0;
@@ -447,677 +397,10 @@ void Convert::copyStructureArray(
to->put(0,from->getLength(),from->getVector(),0);
}
size_t Convert::toByteArray(PVScalarArrayPtr const &pv, size_t offset, size_t length,
int8 to[], size_t toOffset)
{
return convertToByteArray(pv.get(), offset, length, to, toOffset);
}
size_t Convert::toShortArray(PVScalarArrayPtr const &pv, size_t offset, size_t length,
int16 to[], size_t toOffset)
{
return convertToShortArray(pv.get(), offset, length, to, toOffset);
}
size_t Convert::toIntArray(PVScalarArrayPtr const &pv, size_t offset, size_t length,
int32 to[], size_t toOffset)
{
return convertToIntArray(pv.get(), offset, length, to, toOffset);
}
size_t Convert::toLongArray(PVScalarArrayPtr const &pv, size_t offset, size_t length,
int64 to[], size_t toOffset)
{
return convertToLongArray(pv.get(), offset, length, to, toOffset);
}
size_t Convert::toUByteArray(PVScalarArrayPtr const &pv, size_t offset, size_t length,
uint8 to[], size_t toOffset)
{
return convertToUByteArray(pv.get(), offset, length, to, toOffset);
}
size_t Convert::toUShortArray(PVScalarArrayPtr const &pv, size_t offset, size_t length,
uint16 to[], size_t toOffset)
{
return convertToUShortArray(pv.get(), offset, length, to, toOffset);
}
size_t Convert::toUIntArray(PVScalarArrayPtr const &pv, size_t offset, size_t length,
uint32 to[], size_t toOffset)
{
return convertToUIntArray(pv.get(), offset, length, to, toOffset);
}
size_t Convert::toULongArray(PVScalarArrayPtr const &pv, size_t offset, size_t length,
uint64 to[], size_t toOffset)
{
return convertToULongArray(pv.get(), offset, length, to, toOffset);
}
size_t Convert::toFloatArray(PVScalarArrayPtr const &pv, size_t offset, size_t length,
float to[], size_t toOffset)
{
return convertToFloatArray(pv.get(), offset, length, to, toOffset);
}
size_t Convert::toDoubleArray(PVScalarArrayPtr const &pv, size_t offset, size_t length,
double to[], size_t toOffset)
{
return convertToDoubleArray(pv.get(), offset, length, to, toOffset);
}
size_t Convert::fromByteArray(PVScalarArrayPtr &pv, size_t offset, size_t length,
const int8 from[], size_t fromOffset)
{
return convertFromByteArray(pv.get(), offset, length, from, fromOffset);
}
size_t Convert::fromByteArray(PVScalarArrayPtr &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 &pv, size_t offset, size_t length,
const int16 from[], size_t fromOffset)
{
return convertFromShortArray(pv.get(), offset, length, from, fromOffset);
}
size_t Convert::fromShortArray(PVScalarArrayPtr &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 &pv, size_t offset, size_t length,
const int32 from[], size_t fromOffset)
{
return convertFromIntArray(pv.get(), offset, length, from, fromOffset);
}
size_t Convert::fromIntArray(PVScalarArrayPtr &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 &pv, size_t offset, size_t length,
const int64 from[], size_t fromOffset)
{
return convertFromLongArray(pv.get(), offset, length, from, fromOffset);
}
size_t Convert::fromLongArray(PVScalarArrayPtr &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 &pv, size_t offset, size_t length,
const uint8 from[], size_t fromOffset)
{
return convertFromUByteArray(pv.get(), offset, length, from, fromOffset);
}
size_t Convert::fromUByteArray(PVScalarArrayPtr &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 &pv, size_t offset, size_t length,
const uint16 from[], size_t fromOffset)
{
return convertFromUShortArray(pv.get(), offset, length, from, fromOffset);
}
size_t Convert::fromUShortArray(PVScalarArrayPtr &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 &pv, size_t offset, size_t length,
const uint32 from[], size_t fromOffset)
{
return convertFromUIntArray(pv.get(), offset, length, from, fromOffset);
}
size_t Convert::fromUIntArray(PVScalarArrayPtr &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 &pv, size_t offset, size_t length,
const uint64 from[], size_t fromOffset)
{
return convertFromULongArray(pv.get(), offset, length, from, fromOffset);
}
size_t Convert::fromULongArray(PVScalarArrayPtr &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 &pv, size_t offset, size_t length,
const float from[], size_t fromOffset)
{
return convertFromFloatArray(pv.get(), offset, length, from, fromOffset);
}
size_t Convert::fromFloatArray(PVScalarArrayPtr &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 &pv, size_t offset, size_t length,
const double from[], size_t fromOffset)
{
return convertFromDoubleArray(pv.get(), offset, length, from, fromOffset);
}
size_t Convert::fromDoubleArray(PVScalarArrayPtr &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)
{
newLineImpl(buffer,indentLevel);
}
template<typename PVT,typename T>
size_t convertFromScalarArray(PVScalarArray *pv,
size_t offset, size_t len,const T from[], size_t fromOffset)
{
ScalarType elemType = pv->getScalarArray()->getElementType();
size_t ntransfered = 0;
String xx = typeid(PVT).name();
String yy = typeid(T).name();
if(xx.compare(yy)== 0) {
PVT *pvdata = static_cast<PVT*>(pv);
while (len > 0) {
size_t n = pvdata->put(offset, len, from, fromOffset);
if (n == 0)
break;
len -= n;
offset += n;
fromOffset += n;
ntransfered += n;
}
return ntransfered;
}
switch (elemType) {
case pvBoolean: {
String message("convert from numeric array to BooleanArray not legal");
throw std::invalid_argument(message);
}
case pvByte: {
PVByteArray *pvdata = static_cast<PVByteArray*>(pv);
int8 data[1];
while (len > 0) {
data[0] = static_cast<int8>(from[fromOffset]);
if (pvdata->put(offset, 1, data, 0) == 0)
return ntransfered;
--len;
++ntransfered;
++offset;
++fromOffset;
}
return ntransfered;
}
case pvShort: {
PVShortArray *pvdata = static_cast<PVShortArray*>(pv);
int16 data[1];
while (len > 0) {
data[0] = static_cast<int16>(from[fromOffset]);
if (pvdata->put(offset, 1, data, 0) == 0)
return ntransfered;
--len;
++ntransfered;
++offset;
++fromOffset;
}
return ntransfered;
}
case pvInt: {
PVIntArray *pvdata = static_cast<PVIntArray*>(pv);
int32 data[1];
while (len > 0) {
data[0] = static_cast<int32>(from[fromOffset]);
if (pvdata->put(offset, 1, data, 0) == 0)
return ntransfered;
--len;
++ntransfered;
++offset;
++fromOffset;
}
return ntransfered;
}
case pvLong: {
PVLongArray *pvdata = static_cast<PVLongArray*>(pv);
int64 data[1];
while (len > 0) {
data[0] = static_cast<int64>(from[fromOffset]);
if (pvdata->put(offset, 1, data, 0) == 0)
return ntransfered;
--len;
++ntransfered;
++offset;
++fromOffset;
}
return ntransfered;
}
case pvUByte: {
PVUByteArray *pvdata = static_cast<PVUByteArray*>(pv);
uint8 data[1];
while (len > 0) {
data[0] = static_cast<uint8>(from[fromOffset]);
if (pvdata->put(offset, 1, data, 0) == 0)
return ntransfered;
--len;
++ntransfered;
++offset;
++fromOffset;
}
return ntransfered;
}
case pvUShort: {
PVUShortArray *pvdata = static_cast<PVUShortArray*>(pv);
uint16 data[1];
while (len > 0) {
data[0] = static_cast<uint16>(from[fromOffset]);
if (pvdata->put(offset, 1, data, 0) == 0)
return ntransfered;
--len;
++ntransfered;
++offset;
++fromOffset;
}
return ntransfered;
}
case pvUInt: {
PVUIntArray *pvdata = static_cast<PVUIntArray*>(pv);
uint32 data[1];
while (len > 0) {
data[0] = static_cast<uint32>(from[fromOffset]);
if (pvdata->put(offset, 1, data, 0) == 0)
return ntransfered;
--len;
++ntransfered;
++offset;
++fromOffset;
}
return ntransfered;
}
case pvULong: {
PVULongArray *pvdata = static_cast<PVULongArray*>(pv);
uint64 data[1];
while (len > 0) {
data[0] = static_cast<uint64>(from[fromOffset]);
if (pvdata->put(offset, 1, data, 0) == 0)
return ntransfered;
--len;
++ntransfered;
++offset;
++fromOffset;
}
return ntransfered;
}
case pvFloat: {
PVFloatArray *pvdata = static_cast<PVFloatArray*>(pv);
float data[1];
while (len > 0) {
data[0] = static_cast<float>(from[fromOffset]);
if (pvdata->put(offset, 1, data, 0) == 0)
return ntransfered;
--len;
++ntransfered;
++offset;
++fromOffset;
}
return ntransfered;
}
case pvDouble: {
PVDoubleArray *pvdata = static_cast<PVDoubleArray*>(pv);
double data[1];
while (len > 0) {
data[0] = static_cast<double>(from[fromOffset]);
if (pvdata->put(offset, 1, data, 0) == 0)
return ntransfered;
--len;
++ntransfered;
++offset;
++fromOffset;
}
return ntransfered;
}
case pvString: {
String message("convert from byte[] to StringArray not legal");
throw std::invalid_argument(message);
}
}
String message("Convert::convertFromByteArray should never get here");
throw std::logic_error(message);
}
template<typename T>
size_t convertToScalarArray(PVScalarArray *pv,
size_t offset, size_t len,T to[], size_t toOffset)
{
ScalarType elemType = pv->getScalarArray()->getElementType();
size_t ntransfered = 0;
switch (elemType) {
case pvBoolean: {
String message("convert BooleanArray to byte[]] not legal");
throw std::invalid_argument(message);
}
case pvByte: {
PVByteArray *pvdata = static_cast<PVByteArray*>(pv);
ByteArrayData data;
while (len > 0) {
size_t num = 0;
num = pvdata->get(offset,len,data);
if (num <= 0) break;
ByteArray & dataArray = data.data;
size_t dataOffset = data.offset;
for(size_t i=0;i<num;i++) to[toOffset+i] = dataArray[dataOffset+1];
len -= num;
offset += num;
toOffset += num;
ntransfered += num;
}
return ntransfered;
}
case pvShort: {
PVShortArray *pvdata = static_cast<PVShortArray*>(pv);
ShortArrayData data;
while (len > 0) {
size_t num = pvdata->get(offset, len, data);
if (num == 0) break;
ShortArray & dataArray = data.data;
size_t dataOffset = data.offset;
for (size_t i = 0; i < num; i++)
to[i + toOffset] = dataArray[i + dataOffset];
len -= num;
offset += num;
toOffset += num;
ntransfered += num;
}
return ntransfered;
}
case pvInt: {
PVIntArray *pvdata = static_cast<PVIntArray*>(pv);
IntArrayData data;
while (len > 0) {
size_t num = pvdata->get(offset, len, data);
if (num == 0) break;
IntArray & dataArray = data.data;
size_t dataOffset = data.offset;
for (size_t i = 0; i < num; i++)
to[i + toOffset] = dataArray[i + dataOffset];
len -= num;
offset += num;
toOffset += num;
ntransfered += num;
}
return ntransfered;
}
case pvLong: {
PVLongArray *pvdata = static_cast<PVLongArray*>(pv);
LongArrayData data;
while (len > 0) {
size_t num = pvdata->get(offset, len, data);
if (num == 0)
break;
LongArray & dataArray = data.data;
size_t dataOffset = data.offset;
for (size_t i = 0; i < num; i++)
to[i + toOffset] = dataArray[i + dataOffset];
len -= num;
offset += num;
toOffset += num;
ntransfered += num;
}
return ntransfered;
}
case pvUByte: {
PVUByteArray *pvdata = static_cast<PVUByteArray*>(pv);
UByteArrayData data;
while (len > 0) {
size_t num = 0;
num = pvdata->get(offset,len,data);
if (num <= 0) break;
UByteArray & dataArray = data.data;
size_t dataOffset = data.offset;
for(size_t i=0;i<num;i++) to[toOffset+i] = dataArray[dataOffset+1];
len -= num;
offset += num;
toOffset += num;
ntransfered += num;
}
return ntransfered;
}
case pvUShort: {
PVUShortArray *pvdata = static_cast<PVUShortArray*>(pv);
UShortArrayData data;
while (len > 0) {
size_t num = pvdata->get(offset, len, data);
if (num == 0) break;
UShortArray & dataArray = data.data;
size_t dataOffset = data.offset;
for (size_t i = 0; i < num; i++)
to[i + toOffset] = dataArray[i + dataOffset];
len -= num;
offset += num;
toOffset += num;
ntransfered += num;
}
return ntransfered;
}
case pvUInt: {
PVUIntArray *pvdata = static_cast<PVUIntArray*>(pv);
UIntArrayData data;
while (len > 0) {
size_t num = pvdata->get(offset, len, data);
if (num == 0) break;
UIntArray & dataArray = data.data;
size_t dataOffset = data.offset;
for (size_t i = 0; i < num; i++)
to[i + toOffset] = dataArray[i + dataOffset];
len -= num;
offset += num;
toOffset += num;
ntransfered += num;
}
return ntransfered;
}
case pvULong: {
PVULongArray *pvdata = static_cast<PVULongArray*>(pv);
ULongArrayData data;
while (len > 0) {
size_t num = pvdata->get(offset, len, data);
if (num == 0)
break;
ULongArray & dataArray = data.data;
size_t dataOffset = data.offset;
for (size_t i = 0; i < num; i++)
to[i + toOffset] = dataArray[i + dataOffset];
len -= num;
offset += num;
toOffset += num;
ntransfered += num;
}
return ntransfered;
}
case pvFloat: {
PVFloatArray *pvdata = static_cast<PVFloatArray*>(pv);
FloatArrayData data;
while (len > 0) {
size_t num = pvdata->get(offset, len, data);
if (num == 0) break;
FloatArray & dataArray = data.data;
size_t dataOffset = data.offset;
for (size_t i = 0; i < num; i++)
to[i + toOffset] = static_cast<T>(dataArray[i + dataOffset]);
len -= num;
offset += num;
toOffset += num;
ntransfered += num;
}
return ntransfered;
}
case pvDouble: {
PVDoubleArray *pvdata = static_cast<PVDoubleArray*>(pv);
DoubleArrayData data;
while (len > 0) {
size_t num = pvdata->get(offset, len, data);
if (num == 0)
break;
DoubleArray & dataArray = data.data;
size_t dataOffset = data.offset;
for (size_t i = 0; i < num; i++)
to[i + toOffset] = static_cast<T>(dataArray[i + dataOffset]);
len -= num;
offset += num;
toOffset += num;
ntransfered += num;
}
return ntransfered;
}
case pvString: {
String message("convert StringArray to numeric not legal");
throw std::invalid_argument(message);
}
}
String message("Convert::convertToScalarArray should never get here");
throw std::logic_error(message);
}
size_t convertFromByteArray(PVScalarArray *pv,
size_t offset, size_t len,const int8 from[], size_t fromOffset)
{
return convertFromScalarArray<PVByteArray,int8>(pv,offset,len,from,fromOffset);
}
size_t convertToByteArray(PVScalarArray * pv,
size_t offset, size_t len,int8 to[], size_t toOffset)
{
return convertToScalarArray<int8>(pv,offset,len,to,toOffset);
}
size_t convertFromShortArray(PVScalarArray *pv,
size_t offset, size_t len,const int16 from[], size_t fromOffset)
{
return convertFromScalarArray<PVShortArray,int16>(pv,offset,len,from,fromOffset);
}
size_t convertToShortArray(PVScalarArray * pv,
size_t offset, size_t len,int16 to[], size_t toOffset)
{
return convertToScalarArray<int16>(pv,offset,len,to,toOffset);
}
size_t convertFromIntArray(PVScalarArray *pv,
size_t offset, size_t len,const int32 from[], size_t fromOffset)
{
return convertFromScalarArray<PVIntArray,int32>(pv,offset,len,from,fromOffset);
}
size_t convertToIntArray(PVScalarArray * pv,
size_t offset, size_t len,int32 to[], size_t toOffset)
{
return convertToScalarArray<int32>(pv,offset,len,to,toOffset);
}
size_t convertFromLongArray(PVScalarArray *pv,
size_t offset, size_t len,const int64 from[], size_t fromOffset)
{
return convertFromScalarArray<PVLongArray,int64>(pv,offset,len,from,fromOffset);
}
size_t convertToLongArray(PVScalarArray * pv,
size_t offset, size_t len,int64 to[], size_t toOffset)
{
return convertToScalarArray<int64>(pv,offset,len,to,toOffset);
}
size_t convertFromUByteArray(PVScalarArray *pv,
size_t offset, size_t len,const uint8 from[], size_t fromOffset)
{
return convertFromScalarArray<PVUByteArray,uint8>(pv,offset,len,from,fromOffset);
}
size_t convertToUByteArray(PVScalarArray * pv,
size_t offset, size_t len,uint8 to[], size_t toOffset)
{
return convertToScalarArray<uint8>(pv,offset,len,to,toOffset);
}
size_t convertFromUShortArray(PVScalarArray *pv,
size_t offset, size_t len,const uint16 from[], size_t fromOffset)
{
return convertFromScalarArray<PVUShortArray,uint16>(pv,offset,len,from,fromOffset);
}
size_t convertToUShortArray(PVScalarArray * pv,
size_t offset, size_t len,uint16 to[], size_t toOffset)
{
return convertToScalarArray<uint16>(pv,offset,len,to,toOffset);
}
size_t convertFromUIntArray(PVScalarArray *pv,
size_t offset, size_t len,const uint32 from[], size_t fromOffset)
{
return convertFromScalarArray<PVUIntArray,uint32>(pv,offset,len,from,fromOffset);
}
size_t convertToUIntArray(PVScalarArray * pv,
size_t offset, size_t len,uint32 to[], size_t toOffset)
{
return convertToScalarArray<uint32>(pv,offset,len,to,toOffset);
}
size_t convertFromULongArray(PVScalarArray *pv,
size_t offset, size_t len,const uint64 from[], size_t fromOffset)
{
return convertFromScalarArray<PVULongArray,uint64>(pv,offset,len,from,fromOffset);
}
size_t convertToULongArray(PVScalarArray * pv,
size_t offset, size_t len,uint64 to[], size_t toOffset)
{
return convertToScalarArray<uint64>(pv,offset,len,to,toOffset);
}
size_t convertFromFloatArray(PVScalarArray *pv,
size_t offset, size_t len,const float from[], size_t fromOffset)
{
return convertFromScalarArray<PVFloatArray,float>(pv,offset,len,from,fromOffset);
}
size_t convertToFloatArray(PVScalarArray * pv,
size_t offset, size_t len,float to[], size_t toOffset)
{
return convertToScalarArray<float>(pv,offset,len,to,toOffset);
}
size_t convertFromDoubleArray(PVScalarArray *pv,
size_t offset, size_t len,const double from[], size_t fromOffset)
{
return convertFromScalarArray<PVDoubleArray,double>(pv,offset,len,from,fromOffset);
}
size_t convertToDoubleArray(PVScalarArray * pv,
size_t offset, size_t len,double to[], size_t toOffset)
{
return convertToScalarArray<double>(pv,offset,len,to,toOffset);
*buffer += "\n";
*buffer += String(indentLevel*4, ' ');
}
ConvertPtr Convert::getConvert()
pvDataApp/pv/convert.h
+90 -30
View File
@@ -446,11 +446,13 @@ public:
* @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);
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
@@ -461,11 +463,13 @@ public:
* @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);
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
@@ -476,11 +480,13 @@ public:
* @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);
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
@@ -491,11 +497,13 @@ public:
* @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);
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
@@ -506,11 +514,13 @@ public:
* @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);
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
@@ -521,11 +531,13 @@ public:
* @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);
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
@@ -536,12 +548,14 @@ public:
* @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);
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
@@ -552,12 +566,14 @@ public:
* @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);
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
@@ -568,12 +584,14 @@ public:
* @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);
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
@@ -584,12 +602,14 @@ public:
* @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);
toOffset)
{ pv->getAs<pvDouble>(to+toOffset, length, offset); return length; }
/**
* Convert a PV array from a byte array.
* @param pv a PV
@@ -600,12 +620,16 @@ public:
* @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);
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);
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
@@ -616,12 +640,16 @@ public:
* @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);
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);
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
@@ -632,12 +660,16 @@ public:
* @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);
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);
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
@@ -648,12 +680,16 @@ public:
* @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);
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);
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
@@ -664,12 +700,16 @@ public:
* @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);
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);
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
@@ -680,12 +720,16 @@ public:
* @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);
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);
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
@@ -696,12 +740,16 @@ public:
* @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);
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);
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
@@ -712,12 +760,16 @@ public:
* @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);
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);
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
@@ -728,12 +780,16 @@ public:
* @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);
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);
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
@@ -744,12 +800,16 @@ public:
* @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);
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);
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.