replace scalar to/from in Convert
This commit is contained in:
Michael Davidsaver
@@ -30,307 +30,6 @@ static void newLineImpl(StringBuilder buffer, int indentLevel)
|
||||
for(int i=0; i<indentLevel; i++) *buffer += " ";
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
T toScalar(PVScalarPtr const &pv)
|
||||
{
|
||||
ScalarConstPtr scalar = pv->getScalar();
|
||||
ScalarType scalarType = scalar->getScalarType();
|
||||
switch(scalarType) {
|
||||
case pvBoolean:
|
||||
throw std::logic_error(String("boolean can not be converted to scalar"));
|
||||
case pvByte: {
|
||||
PVBytePtr value = static_pointer_cast<PVByte>(pv);
|
||||
return value->get();
|
||||
}
|
||||
case pvShort: {
|
||||
PVShortPtr value = static_pointer_cast<PVShort>(pv);
|
||||
return value->get();
|
||||
}
|
||||
case pvInt: {
|
||||
PVIntPtr value = static_pointer_cast<PVInt>(pv);
|
||||
return value->get();
|
||||
}
|
||||
case pvLong: {
|
||||
PVLongPtr value = static_pointer_cast<PVLong>(pv);
|
||||
return value->get();
|
||||
}
|
||||
case pvUByte: {
|
||||
PVUBytePtr value = static_pointer_cast<PVUByte>(pv);
|
||||
return value->get();
|
||||
}
|
||||
case pvUShort: {
|
||||
PVUShortPtr value = static_pointer_cast<PVUShort>(pv);
|
||||
return value->get();
|
||||
}
|
||||
case pvUInt: {
|
||||
PVUIntPtr value = static_pointer_cast<PVUInt>(pv);
|
||||
return value->get();
|
||||
}
|
||||
case pvULong: {
|
||||
PVULongPtr value = static_pointer_cast<PVULong>(pv);
|
||||
return value->get();
|
||||
}
|
||||
case pvFloat: {
|
||||
PVFloatPtr value = static_pointer_cast<PVFloat>(pv);
|
||||
return static_cast<T>(value->get());
|
||||
}
|
||||
case pvDouble: {
|
||||
PVDoublePtr value = static_pointer_cast<PVDouble>(pv);
|
||||
return static_cast<T>(value->get());
|
||||
}
|
||||
case pvString:
|
||||
throw std::logic_error(String("string can not be converted to byte"));
|
||||
}
|
||||
throw std::logic_error("Logic error. Should never get here.");
|
||||
}
|
||||
|
||||
int8 Convert::toByte(PVScalarPtr const & pv)
|
||||
{
|
||||
return toScalar<int8>(pv);
|
||||
}
|
||||
|
||||
int16 Convert::toShort(PVScalarPtr const & pv)
|
||||
{
|
||||
return toScalar<int16>(pv);
|
||||
}
|
||||
|
||||
int32 Convert::toInt(PVScalarPtr const & pv)
|
||||
{
|
||||
return toScalar<int32>(pv);
|
||||
}
|
||||
|
||||
int64 Convert::toLong(PVScalarPtr const & pv)
|
||||
{
|
||||
return toScalar<int64>(pv);
|
||||
}
|
||||
|
||||
uint8 Convert::toUByte(PVScalarPtr const & pv)
|
||||
{
|
||||
return toScalar<uint8>(pv);
|
||||
}
|
||||
|
||||
uint16 Convert::toUShort(PVScalarPtr const & pv)
|
||||
{
|
||||
return toScalar<uint16>(pv);
|
||||
}
|
||||
|
||||
uint32 Convert::toUInt(PVScalarPtr const & pv)
|
||||
{
|
||||
return toScalar<uint32>(pv);
|
||||
}
|
||||
|
||||
uint64 Convert::toULong(PVScalarPtr const &pv)
|
||||
{
|
||||
return toScalar<uint64>(pv);
|
||||
}
|
||||
|
||||
float Convert::toFloat(PVScalarPtr const &pv)
|
||||
{
|
||||
return toScalar<float>(pv);
|
||||
}
|
||||
|
||||
double Convert::toDouble(PVScalarPtr const & pv)
|
||||
{
|
||||
return toScalar<double>(pv);
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
String scalarToString(T);
|
||||
|
||||
template<>
|
||||
String scalarToString<int8>(int8 value)
|
||||
{
|
||||
char buffer[20];
|
||||
int ival = value;
|
||||
sprintf(buffer,"%d",ival);
|
||||
return String(buffer);
|
||||
}
|
||||
|
||||
template<>
|
||||
String scalarToString<int16>(int16 value)
|
||||
{
|
||||
char buffer[20];
|
||||
int ival = value;
|
||||
sprintf(buffer,"%d",ival);
|
||||
return String(buffer);
|
||||
}
|
||||
|
||||
template<>
|
||||
String scalarToString<int32>(int32 value)
|
||||
{
|
||||
char buffer[20];
|
||||
int ival = value;
|
||||
sprintf(buffer,"%d",ival);
|
||||
return String(buffer);
|
||||
}
|
||||
|
||||
template<>
|
||||
String scalarToString<int64>(int64 value)
|
||||
{
|
||||
char buffer[30];
|
||||
sprintf(buffer,"%lld",(long long)value);
|
||||
return String(buffer);
|
||||
}
|
||||
|
||||
template<>
|
||||
String scalarToString<uint8>(uint8 value)
|
||||
{
|
||||
char buffer[20];
|
||||
unsigned int ival = value;
|
||||
sprintf(buffer,"%ud",ival);
|
||||
return String(buffer);
|
||||
}
|
||||
|
||||
template<>
|
||||
String scalarToString<uint16>(uint16 value)
|
||||
{
|
||||
char buffer[20];
|
||||
unsigned int ival = value;
|
||||
sprintf(buffer,"%iud",ival);
|
||||
return String(buffer);
|
||||
}
|
||||
|
||||
template<>
|
||||
String scalarToString<uint32>(uint32 value)
|
||||
{
|
||||
char buffer[20];
|
||||
sprintf(buffer,"%ud",(unsigned int)value);
|
||||
return String(buffer);
|
||||
}
|
||||
|
||||
template<>
|
||||
String scalarToString<uint64>(uint64 value)
|
||||
{
|
||||
char buffer[30];
|
||||
sprintf(buffer,"%llu",(unsigned long long)value);
|
||||
return String(buffer);
|
||||
}
|
||||
|
||||
template<>
|
||||
String scalarToString<float>(float value)
|
||||
{
|
||||
char buffer[40];
|
||||
sprintf(buffer,"%g",value);
|
||||
return String(buffer);
|
||||
}
|
||||
|
||||
template<>
|
||||
String scalarToString<double>(double value)
|
||||
{
|
||||
char buffer[40];
|
||||
sprintf(buffer,"%g",value);
|
||||
return String(buffer);
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
void fromScalar(PVScalarPtr const &pv,T from)
|
||||
{
|
||||
ScalarConstPtr scalar = pv->getScalar();
|
||||
ScalarType scalarType = scalar->getScalarType();
|
||||
switch(scalarType) {
|
||||
case pvBoolean:
|
||||
throw std::logic_error("byte can not be converted to boolean");
|
||||
case pvByte: {
|
||||
PVBytePtr value = static_pointer_cast<PVByte>(pv);
|
||||
value->put(static_cast<PVByte::value_type>(from)); return;
|
||||
}
|
||||
case pvShort: {
|
||||
PVShortPtr value = static_pointer_cast<PVShort>(pv);
|
||||
value->put(static_cast<PVShort::value_type>(from)); return;
|
||||
}
|
||||
case pvInt: {
|
||||
PVIntPtr value = static_pointer_cast<PVInt>(pv);
|
||||
value->put(static_cast<PVInt::value_type>(from)); return;
|
||||
}
|
||||
case pvLong: {
|
||||
PVLongPtr value = static_pointer_cast<PVLong>(pv);
|
||||
value->put(static_cast<PVLong::value_type>(from)); return;
|
||||
}
|
||||
case pvUByte: {
|
||||
PVUBytePtr value = static_pointer_cast<PVUByte>(pv);
|
||||
value->put(static_cast<PVUByte::value_type>(from)); return;
|
||||
}
|
||||
case pvUShort: {
|
||||
PVUShortPtr value = static_pointer_cast<PVUShort>(pv);
|
||||
value->put(static_cast<PVUShort::value_type>(from)); return;
|
||||
}
|
||||
case pvUInt: {
|
||||
PVUIntPtr value = static_pointer_cast<PVUInt>(pv);
|
||||
value->put(static_cast<PVUInt::value_type>(from)); return;
|
||||
}
|
||||
case pvULong: {
|
||||
PVULongPtr value = static_pointer_cast<PVULong>(pv);
|
||||
value->put(static_cast<PVULong::value_type>(from)); return;
|
||||
}
|
||||
case pvFloat: {
|
||||
PVFloatPtr value = static_pointer_cast<PVFloat>(pv);
|
||||
value->put(static_cast<PVFloat::value_type>(from)); return;
|
||||
}
|
||||
case pvDouble: {
|
||||
PVDoublePtr value = static_pointer_cast<PVDouble>(pv);
|
||||
value->put(static_cast<PVDouble::value_type>(from)); return;
|
||||
}
|
||||
case pvString: {
|
||||
PVStringPtr pvvalue = static_pointer_cast<PVString>(pv);
|
||||
String value = scalarToString<T>(from);
|
||||
pvvalue->put(value);
|
||||
return;
|
||||
}
|
||||
}
|
||||
throw std::logic_error("Logic error. Should never get here.");
|
||||
}
|
||||
|
||||
void Convert::fromByte(PVScalarPtr const &pv,int8 from)
|
||||
{
|
||||
fromScalar<int8>(pv,from);
|
||||
}
|
||||
|
||||
void Convert::fromShort(PVScalarPtr const &pv,int16 from)
|
||||
{
|
||||
fromScalar<int16>(pv,from);
|
||||
}
|
||||
|
||||
void Convert::fromInt(PVScalarPtr const &pv, int32 from)
|
||||
{
|
||||
fromScalar<int32>(pv,from);
|
||||
}
|
||||
|
||||
void Convert::fromLong(PVScalarPtr const &pv, int64 from)
|
||||
{
|
||||
fromScalar<int64>(pv,from);
|
||||
}
|
||||
|
||||
void Convert::fromUByte(PVScalarPtr const &pv,uint8 from)
|
||||
{
|
||||
fromScalar<uint8>(pv,from);
|
||||
}
|
||||
|
||||
void Convert::fromUShort(PVScalarPtr const &pv,uint16 from)
|
||||
{
|
||||
fromScalar<uint16>(pv,from);
|
||||
}
|
||||
|
||||
void Convert::fromUInt(PVScalarPtr const &pv, uint32 from)
|
||||
{
|
||||
fromScalar<uint32>(pv,from);
|
||||
}
|
||||
|
||||
void Convert::fromULong(PVScalarPtr const &pv, uint64 from)
|
||||
{
|
||||
fromScalar<uint64>(pv,from);
|
||||
}
|
||||
|
||||
void Convert::fromFloat(PVScalarPtr const &pv, float from)
|
||||
{
|
||||
fromScalar<float>(pv,from);
|
||||
}
|
||||
|
||||
void Convert::fromDouble(PVScalarPtr const &pv, double from)
|
||||
{
|
||||
fromScalar<double>(pv,from);
|
||||
}
|
||||
|
||||
|
||||
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,
|
||||
@@ -372,9 +71,6 @@ static size_t convertFromDoubleArray(PVScalarArray *pv, size_t offset,
|
||||
static size_t convertToDoubleArray(PVScalarArray *pv, size_t offset,
|
||||
size_t len,double to[], size_t toOffset);
|
||||
|
||||
static size_t copyArrayDataReference(PVScalarArray *from,PVArray *to);
|
||||
static size_t copyNumericArray(PVScalarArray *from,
|
||||
size_t offset, PVScalarArray *to, size_t toOffset, size_t len);
|
||||
|
||||
static std::vector<String> split(String commaSeparatedList);
|
||||
|
||||
@@ -751,87 +447,6 @@ void Convert::copyStructureArray(
|
||||
to->put(0,from->getLength(),from->getVector(),0);
|
||||
}
|
||||
|
||||
String Convert::toString(PVScalarPtr const & pv)
|
||||
{
|
||||
static String trueString("true");
|
||||
static String falseString("false");
|
||||
|
||||
ScalarConstPtr scalar = pv->getScalar();
|
||||
ScalarType scalarType = scalar->getScalarType();
|
||||
switch(scalarType) {
|
||||
case pvBoolean: {
|
||||
PVBooleanPtr pvalue = static_pointer_cast<PVBoolean>(pv);
|
||||
boolean value = pvalue->get();
|
||||
return value ? trueString : falseString;
|
||||
}
|
||||
case pvByte: {
|
||||
PVBytePtr value = static_pointer_cast<PVByte>(pv);
|
||||
char buffer[30];
|
||||
sprintf(buffer,"%d",(int)value->get());
|
||||
return String(buffer);
|
||||
}
|
||||
case pvShort: {
|
||||
PVShortPtr value = static_pointer_cast<PVShort>(pv);
|
||||
char buffer[30];
|
||||
sprintf(buffer,"%d",(int)value->get());
|
||||
return String(buffer);
|
||||
}
|
||||
case pvInt: {
|
||||
PVIntPtr value = static_pointer_cast<PVInt>(pv);
|
||||
char buffer[30];
|
||||
sprintf(buffer,"%d",(int)value->get());
|
||||
return String(buffer);
|
||||
}
|
||||
case pvLong: {
|
||||
PVLongPtr value = static_pointer_cast<PVLong>(pv);
|
||||
char buffer[30];
|
||||
sprintf(buffer,"%lli",(long long int)value->get());
|
||||
return String(buffer);
|
||||
}
|
||||
case pvUByte: {
|
||||
PVUBytePtr value = static_pointer_cast<PVUByte>(pv);
|
||||
char buffer[30];
|
||||
sprintf(buffer,"%u",(unsigned int)value->get());
|
||||
return String(buffer);
|
||||
}
|
||||
case pvUShort: {
|
||||
PVUShortPtr value = static_pointer_cast<PVUShort>(pv);
|
||||
char buffer[30];
|
||||
sprintf(buffer,"%u",(unsigned int)value->get());
|
||||
return String(buffer);
|
||||
}
|
||||
case pvUInt: {
|
||||
PVUIntPtr value = static_pointer_cast<PVUInt>(pv);
|
||||
char buffer[30];
|
||||
sprintf(buffer,"%u",(unsigned int)value->get());
|
||||
return String(buffer);
|
||||
}
|
||||
case pvULong: {
|
||||
PVULongPtr value = static_pointer_cast<PVULong>(pv);
|
||||
char buffer[30];
|
||||
sprintf(buffer,"%llu",(unsigned long long int)value->get());
|
||||
return String(buffer);
|
||||
}
|
||||
case pvFloat: {
|
||||
PVFloatPtr value = static_pointer_cast<PVFloat>(pv);
|
||||
char buffer[30];
|
||||
sprintf(buffer,"%g",value->get());
|
||||
return String(buffer);
|
||||
}
|
||||
case pvDouble: {
|
||||
PVDoublePtr value = static_pointer_cast<PVDouble>(pv);
|
||||
char buffer[30];
|
||||
sprintf(buffer,"%g",value->get());
|
||||
return String(buffer);
|
||||
}
|
||||
case pvString: {
|
||||
PVStringPtr value = static_pointer_cast<PVString>(pv);
|
||||
return value->get();
|
||||
}
|
||||
}
|
||||
throw std::logic_error("Logic error. Should never get here.");
|
||||
}
|
||||
|
||||
size_t Convert::toByteArray(PVScalarArrayPtr const &pv, size_t offset, size_t length,
|
||||
int8 to[], size_t toOffset)
|
||||
{
|
||||
@@ -1505,332 +1120,6 @@ size_t convertToDoubleArray(PVScalarArray * pv,
|
||||
return convertToScalarArray<double>(pv,offset,len,to,toOffset);
|
||||
}
|
||||
|
||||
size_t copyArrayDataReference(PVScalarArray *from,PVArray *to)
|
||||
{
|
||||
ScalarType scalarType = from->getScalarArray()->getElementType();
|
||||
switch (scalarType) {
|
||||
case pvBoolean: {
|
||||
PVBooleanArray *pvfrom = (PVBooleanArray*) from;
|
||||
PVBooleanArray *pvto = (PVBooleanArray*) to;
|
||||
pvto->shareData(
|
||||
pvfrom->getSharedVector(),pvfrom->getCapacity(),pvfrom->getLength());
|
||||
break;
|
||||
}
|
||||
case pvByte: {
|
||||
PVByteArray *pvfrom = (PVByteArray*) from;
|
||||
PVByteArray *pvto = (PVByteArray*) to;
|
||||
pvto->shareData(
|
||||
pvfrom->getSharedVector(),pvfrom->getCapacity(),pvfrom->getLength());
|
||||
break;
|
||||
}
|
||||
case pvShort: {
|
||||
PVShortArray *pvfrom = (PVShortArray*) from;
|
||||
PVShortArray *pvto = (PVShortArray*) to;
|
||||
pvto->shareData(
|
||||
pvfrom->getSharedVector(),pvfrom->getCapacity(),pvfrom->getLength());
|
||||
break;
|
||||
}
|
||||
case pvInt: {
|
||||
PVIntArray *pvfrom = (PVIntArray*) from;
|
||||
PVIntArray *pvto = (PVIntArray*) to;
|
||||
pvto->shareData(
|
||||
pvfrom->getSharedVector(),pvfrom->getCapacity(),pvfrom->getLength());
|
||||
break;
|
||||
}
|
||||
case pvLong: {
|
||||
PVLongArray *pvfrom = (PVLongArray*) from;
|
||||
PVLongArray *pvto = (PVLongArray*) to;
|
||||
pvto->shareData(
|
||||
pvfrom->getSharedVector(),pvfrom->getCapacity(),pvfrom->getLength());
|
||||
break;
|
||||
}
|
||||
case pvUByte: {
|
||||
PVUByteArray *pvfrom = (PVUByteArray*) from;
|
||||
PVUByteArray *pvto = (PVUByteArray*) to;
|
||||
pvto->shareData(
|
||||
pvfrom->getSharedVector(),pvfrom->getCapacity(),pvfrom->getLength());
|
||||
break;
|
||||
}
|
||||
case pvUShort: {
|
||||
PVUShortArray *pvfrom = (PVUShortArray*) from;
|
||||
PVUShortArray *pvto = (PVUShortArray*) to;
|
||||
pvto->shareData(
|
||||
pvfrom->getSharedVector(),pvfrom->getCapacity(),pvfrom->getLength());
|
||||
break;
|
||||
}
|
||||
case pvUInt: {
|
||||
PVUIntArray *pvfrom = (PVUIntArray*) from;
|
||||
PVUIntArray *pvto = (PVUIntArray*) to;
|
||||
pvto->shareData(
|
||||
pvfrom->getSharedVector(),pvfrom->getCapacity(),pvfrom->getLength());
|
||||
break;
|
||||
}
|
||||
case pvULong: {
|
||||
PVULongArray *pvfrom = (PVULongArray*) from;
|
||||
PVULongArray *pvto = (PVULongArray*) to;
|
||||
pvto->shareData(
|
||||
pvfrom->getSharedVector(),pvfrom->getCapacity(),pvfrom->getLength());
|
||||
break;
|
||||
}
|
||||
case pvFloat: {
|
||||
PVFloatArray *pvfrom = (PVFloatArray*) from;
|
||||
PVFloatArray *pvto = (PVFloatArray*) to;
|
||||
pvto->shareData(
|
||||
pvfrom->getSharedVector(),pvfrom->getCapacity(),pvfrom->getLength());
|
||||
break;
|
||||
}
|
||||
case pvDouble: {
|
||||
PVDoubleArray *pvfrom = (PVDoubleArray*) from;
|
||||
PVDoubleArray *pvto = (PVDoubleArray*) to;
|
||||
pvto->shareData(
|
||||
pvfrom->getSharedVector(),pvfrom->getCapacity(),pvfrom->getLength());
|
||||
break;
|
||||
}
|
||||
case pvString: {
|
||||
PVStringArray *pvfrom = (PVStringArray*) from;
|
||||
PVStringArray *pvto = (PVStringArray*) to;
|
||||
pvto->shareData(
|
||||
pvfrom->getSharedVector(),pvfrom->getCapacity(),pvfrom->getLength());
|
||||
break;
|
||||
}
|
||||
}
|
||||
to->setImmutable();
|
||||
return from->getLength();
|
||||
}
|
||||
|
||||
size_t copyNumericArray(PVScalarArray *from, size_t offset, PVScalarArray *to, size_t toOffset, size_t len)
|
||||
{
|
||||
ScalarType fromElementType = from->getScalarArray()->getElementType();
|
||||
size_t ncopy = 0;
|
||||
switch (fromElementType) {
|
||||
case pvBoolean:
|
||||
throw std::logic_error(String("PVBooleanArray is not a numeric array"));
|
||||
case pvByte: {
|
||||
PVByteArray *pvfrom = (PVByteArray*) from;
|
||||
while (len > 0) {
|
||||
size_t num = 0;
|
||||
ByteArrayData arrayData = ByteArrayData();
|
||||
num = pvfrom->get(offset, len, arrayData);
|
||||
int8 * data = get(arrayData.data);
|
||||
size_t dataOffset = arrayData.offset;
|
||||
if (num <= 0) break;
|
||||
while (num > 0) {
|
||||
size_t n = convertFromByteArray(
|
||||
to, toOffset, num, data, dataOffset);
|
||||
if (n <= 0) break;
|
||||
len -= n;
|
||||
num -= n;
|
||||
ncopy += n;
|
||||
offset += n;
|
||||
toOffset += n;
|
||||
}
|
||||
}
|
||||
break;
|
||||
}
|
||||
case pvShort: {
|
||||
PVShortArray *pvfrom = (PVShortArray*) from;
|
||||
while (len > 0) {
|
||||
size_t num = 0;
|
||||
ShortArrayData arrayData = ShortArrayData();
|
||||
num = pvfrom->get(offset, len, arrayData);
|
||||
int16 * data = get(arrayData.data);
|
||||
size_t dataOffset = arrayData.offset;
|
||||
if (num <= 0) break;
|
||||
while (num > 0) {
|
||||
size_t n = convertFromShortArray(
|
||||
to, toOffset, num, data, dataOffset);
|
||||
if (n <= 0) break;
|
||||
len -= n;
|
||||
num -= n;
|
||||
ncopy += n;
|
||||
offset += n;
|
||||
toOffset += n;
|
||||
}
|
||||
}
|
||||
break;
|
||||
}
|
||||
case pvInt: {
|
||||
PVIntArray *pvfrom = (PVIntArray*) from;
|
||||
while (len > 0) {
|
||||
size_t num = 0;
|
||||
IntArrayData arrayData = IntArrayData();
|
||||
num = pvfrom->get(offset, len, arrayData);
|
||||
int32 * data = get(arrayData.data);
|
||||
size_t dataOffset = arrayData.offset;
|
||||
if (num <= 0) break;
|
||||
while (num > 0) {
|
||||
size_t n = convertFromIntArray(
|
||||
to, toOffset, num, data, dataOffset);
|
||||
if (n <= 0) break;
|
||||
len -= n;
|
||||
num -= n;
|
||||
ncopy += n;
|
||||
offset += n;
|
||||
toOffset += n;
|
||||
}
|
||||
}
|
||||
break;
|
||||
}
|
||||
case pvLong: {
|
||||
PVLongArray *pvfrom = (PVLongArray*) from;
|
||||
while (len > 0) {
|
||||
size_t num = 0;
|
||||
LongArrayData arrayData = LongArrayData();
|
||||
num = pvfrom->get(offset, len, arrayData);
|
||||
int64 * data = get(arrayData.data);
|
||||
size_t dataOffset = arrayData.offset;
|
||||
if (num <= 0) break;
|
||||
while (num > 0) {
|
||||
size_t n = convertFromLongArray(
|
||||
to, toOffset, num, data, dataOffset);
|
||||
if (n <= 0) break;
|
||||
len -= n;
|
||||
num -= n;
|
||||
ncopy += n;
|
||||
offset += n;
|
||||
toOffset += n;
|
||||
}
|
||||
}
|
||||
break;
|
||||
}
|
||||
case pvUByte: {
|
||||
PVUByteArray *pvfrom = (PVUByteArray*) from;
|
||||
while (len > 0) {
|
||||
size_t num = 0;
|
||||
UByteArrayData arrayData = UByteArrayData();
|
||||
num = pvfrom->get(offset, len, arrayData);
|
||||
uint8 * data = get(arrayData.data);
|
||||
size_t dataOffset = arrayData.offset;
|
||||
if (num <= 0) break;
|
||||
while (num > 0) {
|
||||
size_t n = convertFromUByteArray(
|
||||
to, toOffset, num, data, dataOffset);
|
||||
if (n <= 0) break;
|
||||
len -= n;
|
||||
num -= n;
|
||||
ncopy += n;
|
||||
offset += n;
|
||||
toOffset += n;
|
||||
}
|
||||
}
|
||||
break;
|
||||
}
|
||||
case pvUShort: {
|
||||
PVUShortArray *pvfrom = (PVUShortArray*) from;
|
||||
while (len > 0) {
|
||||
size_t num = 0;
|
||||
UShortArrayData arrayData = UShortArrayData();
|
||||
num = pvfrom->get(offset, len, arrayData);
|
||||
uint16 * data = get(arrayData.data);
|
||||
size_t dataOffset = arrayData.offset;
|
||||
if (num <= 0) break;
|
||||
while (num > 0) {
|
||||
size_t n = convertFromUShortArray(
|
||||
to, toOffset, num, data, dataOffset);
|
||||
if (n <= 0) break;
|
||||
len -= n;
|
||||
num -= n;
|
||||
ncopy += n;
|
||||
offset += n;
|
||||
toOffset += n;
|
||||
}
|
||||
}
|
||||
break;
|
||||
}
|
||||
case pvUInt: {
|
||||
PVUIntArray *pvfrom = (PVUIntArray*) from;
|
||||
while (len > 0) {
|
||||
size_t num = 0;
|
||||
UIntArrayData arrayData = UIntArrayData();
|
||||
num = pvfrom->get(offset, len, arrayData);
|
||||
uint32 * data = get(arrayData.data);
|
||||
size_t dataOffset = arrayData.offset;
|
||||
if (num <= 0) break;
|
||||
while (num > 0) {
|
||||
size_t n = convertFromUIntArray(
|
||||
to, toOffset, num, data, dataOffset);
|
||||
if (n <= 0) break;
|
||||
len -= n;
|
||||
num -= n;
|
||||
ncopy += n;
|
||||
offset += n;
|
||||
toOffset += n;
|
||||
}
|
||||
}
|
||||
break;
|
||||
}
|
||||
case pvULong: {
|
||||
PVULongArray *pvfrom = (PVULongArray*) from;
|
||||
while (len > 0) {
|
||||
size_t num = 0;
|
||||
ULongArrayData arrayData = ULongArrayData();
|
||||
num = pvfrom->get(offset, len, arrayData);
|
||||
uint64 * data = get(arrayData.data);
|
||||
size_t dataOffset = arrayData.offset;
|
||||
if (num <= 0) break;
|
||||
while (num > 0) {
|
||||
size_t n = convertFromULongArray(
|
||||
to, toOffset, num, data, dataOffset);
|
||||
if (n <= 0) break;
|
||||
len -= n;
|
||||
num -= n;
|
||||
ncopy += n;
|
||||
offset += n;
|
||||
toOffset += n;
|
||||
}
|
||||
}
|
||||
break;
|
||||
}
|
||||
case pvFloat: {
|
||||
PVFloatArray *pvfrom = (PVFloatArray*) from;
|
||||
while (len > 0) {
|
||||
size_t num = 0;
|
||||
FloatArrayData floatArrayData = FloatArrayData();
|
||||
num = pvfrom->get(offset, len, floatArrayData);
|
||||
float * data = get(floatArrayData.data);
|
||||
size_t dataOffset = floatArrayData.offset;
|
||||
if (num <= 0) break;
|
||||
while (num > 0) {
|
||||
size_t n = convertFromFloatArray(
|
||||
to, toOffset, num, data, dataOffset);
|
||||
if (n <= 0) break;
|
||||
len -= n;
|
||||
num -= n;
|
||||
ncopy += n;
|
||||
offset += n;
|
||||
toOffset += n;
|
||||
}
|
||||
}
|
||||
break;
|
||||
}
|
||||
case pvDouble: {
|
||||
PVDoubleArray *pvfrom = (PVDoubleArray*) from;
|
||||
while (len > 0) {
|
||||
size_t num = 0;
|
||||
DoubleArrayData doubleArrayData = DoubleArrayData();
|
||||
num = pvfrom->get(offset, len, doubleArrayData);
|
||||
double * data = get(doubleArrayData.data);
|
||||
size_t dataOffset = doubleArrayData.offset;
|
||||
if (num <= 0) break;
|
||||
while (num > 0) {
|
||||
size_t n = convertFromDoubleArray(
|
||||
to, toOffset, num, data, dataOffset);
|
||||
if (n <= 0) break;
|
||||
len -= n;
|
||||
num -= n;
|
||||
ncopy += n;
|
||||
offset += n;
|
||||
toOffset += n;
|
||||
}
|
||||
}
|
||||
break;
|
||||
}
|
||||
case pvString:
|
||||
throw std::logic_error(String("PVStringArray is not a numeric array"));
|
||||
}
|
||||
return ncopy;
|
||||
}
|
||||
|
||||
ConvertPtr Convert::getConvert()
|
||||
{
|
||||
static ConvertPtr convert;
|
||||
|
||||
Reference in New Issue
Block a user