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

721
pvDataApp/factory/Convert.cpp
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()