epics/pvData
0
0
Fork 0
Code Issues Pull Requests Projects Wiki Activity
Files
efdef77461305d149a11a6a0f9d023522e18bc21
pvData/pvDataApp/factory/Convert.cpp

3683 lines
120 KiB
C++
Raw Blame History

/* Convert.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.
*/
#include <cstdio>
#include <string>
#include <vector>
#include <stdexcept>
#include "lock.h"
#include "pvIntrospect.h"
#include "pvData.h"
#include "convert.h"
namespace epics { namespace pvData {
static Convert* convert = 0;
static PVDataCreate* pvDataCreate = 0;
static String trueString("true");
static String falseString("false");
static String logicError("Logic error. Should never get here.");
static String illegalScalarType("Illegal ScalarType");
static bool convertEquals(PVField *a,PVField *b);
static int convertFromByteArray(PVScalarArray *pv, int offset,
int len,int8 from[], int fromOffset);
static int convertToByteArray(PVScalarArray *pv, int offset,
int len,int8 to[], int toOffset);
static int convertFromShortArray(PVScalarArray *pv, int offset,
int len,int16 from[], int fromOffset);
static int convertToShortArray(PVScalarArray *pv, int offset,
int len,int16 to[], int toOffset);
static int convertFromIntArray(PVScalarArray *pv, int offset,
int len,int32 from[], int fromOffset);
static int convertToIntArray(PVScalarArray *pv, int offset,
int len,int32 to[], int toOffset);
static int convertFromLongArray(PVScalarArray *pv, int offset,
int len,int64 from[], int fromOffset);
static int convertToLongArray(PVScalarArray * pv, int offset,
int len,int64 to[], int toOffset);
static int convertFromFloatArray(PVScalarArray *pv, int offset,
int len,float from[], int fromOffset);
static int convertToFloatArray(PVScalarArray * pv, int offset,
int len,float to[], int toOffset);
static int convertFromDoubleArray(PVScalarArray *pv, int offset,
int len,double from[], int fromOffset);
static int convertToDoubleArray(PVScalarArray * pv, int offset,
int len,double to[], int toOffset);
static int convertFromStringArray(PVScalarArray *pv, int offset,
int len,String from[], int fromOffset);
static int convertToStringArray(PVScalarArray * pv, int offset,
int len,String to[], int toOffset);
static void convertToString(StringBuilder buffer,
PVField * pv,int indentLevel);
static void convertStructure(StringBuilder buffer,
PVStructure *data,int indentLevel);
static void convertArray(StringBuilder buffer,
PVScalarArray * pv,int indentLevel);
static void convertStructureArray(StringBuilder buffer,
PVStructureArray * pvdata,int indentLevel);
static int copyArrayDataReference(PVScalarArray *from,PVArray *to);
static int copyNumericArray(PVScalarArray *from,
int offset, PVScalarArray *to, int toOffset, int len);
static std::vector<String> split(String commaSeparatedList);
static std::vector<String> split(String commaSeparatedList) {
String::size_type numValues = 1;
String::size_type index=0;
while(true) {
String::size_type pos = commaSeparatedList.find(',',index);
if(pos==String::npos) break;
numValues++;
index = pos +1;
}
std::vector<String> valueList(numValues,"");
index=0;
for(size_t i=0; i<numValues; i++) {
int pos = commaSeparatedList.find(',',index);
String value = commaSeparatedList.substr(index,pos);
valueList[i] = value;
index = pos +1;
}
return valueList;
}
Convert::Convert(){}
Convert::~Convert(){}
void Convert::getFullName(StringBuilder buf,PVField * pvField)
{
buf->empty();
*buf += pvField->getField()->getFieldName();
PVStructure *parent;
while((parent=pvField->getParent())!=0) {
pvField = pvField->getParent();
String name = pvField->getField()->getFieldName();
if(name.length()>0) {
buf->insert(0,".");
buf->insert(0,name);
}
}
}
bool Convert::equals(PVField *a,PVField *b)
{
return convertEquals(a,b);
}
void Convert::getString(StringBuilder buf,PVField * pvField,int indentLevel)
{
convertToString(buf,pvField,indentLevel);
}
void Convert::getString(StringBuilder buf,PVField * pvField)
{
convertToString(buf,pvField,0);
}
void Convert::fromString(PVScalar *pvScalar, String from)
{
ScalarConstPtr scalar = pvScalar->getScalar();
ScalarType scalarType = scalar->getScalarType();
switch(scalarType) {
case pvBoolean: {
PVBoolean *pv = static_cast<PVBoolean *>(pvScalar);
bool value =
((from.compare("true")==0) ? true : false);
pv->put(value);
return;
}
case pvByte : {
PVByte *pv = static_cast<PVByte*>(pvScalar);
int ival;
sscanf(from.c_str(),"%d",&ival);
int8 value = ival;
pv->put(value);
return;
}
case pvShort : {
PVShort *pv = static_cast<PVShort*>(pvScalar);
int ival;
sscanf(from.c_str(),"%d",&ival);
int16 value = ival;
pv->put(value);
return;
}
case pvInt : {
PVInt *pv = static_cast<PVInt*>(pvScalar);
int ival;
sscanf(from.c_str(),"%d",&ival);
int32 value = ival;
pv->put(value);
return;
}
case pvLong : {
PVLong *pv = static_cast<PVLong*>(pvScalar);
int64 ival;
sscanf(from.c_str(),"%lld",&ival);
int64 value = ival;
pv->put(value);
return;
}
case pvFloat : {
PVFloat *pv = static_cast<PVFloat*>(pvScalar);
float value;
sscanf(from.c_str(),"%f",&value);
pv->put(value);
return;
}
case pvDouble : {
PVDouble*pv = static_cast<PVDouble*>(pvScalar);
double value;
sscanf(from.c_str(),"%lf",&value);
pv->put(value);
return;
}
case pvString: {
PVString *value = static_cast<PVString*>(pvScalar);
value->put(from);
return;
}
}
String message("Convert::fromString unknown scalarType ");
ScalarTypeFunc::toString(&message,scalarType);
throw std::logic_error(message);
}
int Convert::fromString(PVScalarArray *pv, String from)
{
if(from[0]=='[' && from[from.length()]==']') {
int offset = from.rfind(']');
from = from.substr(1, offset);
}
std::vector<String> valueList = split(from);
int length = valueList.size();
StringArray valueArray = new String[length];
for(int i=0; i<length; i++) {
String value = valueList[i];
valueArray[i] = value;
}
int num = fromStringArray(pv,0,length,valueArray,0);
if(num<length) length = num;
pv->setLength(length);
delete[] valueArray;
return length;
}
int Convert::fromStringArray(PVScalarArray *pv, int offset, int length,
String from[], int fromOffset)
{
return convertFromStringArray(pv,offset,length,from,fromOffset);
}
int Convert::toStringArray(PVScalarArray * pv, int offset, int length,
String to[], int toOffset)
{
return convertToStringArray(pv,offset,length,to,toOffset);
}
bool Convert::isCopyCompatible(FieldConstPtr from, FieldConstPtr to)
{
if(from->getType()!=to->getType()) return false;
switch(from->getType()) {
case scalar:
return isCopyScalarCompatible(
static_cast<ScalarConstPtr>(from),
static_cast<ScalarConstPtr>(to));
case scalarArray:
return isCopyScalarArrayCompatible(
static_cast<ScalarArrayConstPtr>(from),
static_cast<ScalarArrayConstPtr>(to));
case structure:
return isCopyStructureCompatible(
static_cast<StructureConstPtr>(from),
static_cast<StructureConstPtr>(to));
case structureArray:
return isCopyStructureArrayCompatible(
static_cast<StructureArrayConstPtr>(from),
static_cast<StructureArrayConstPtr>(to));
}
String message("Convert::isCopyCompatible should never get here");
throw std::logic_error(message);
}
void Convert::copy(PVField *from,PVField *to)
{
switch(from->getField()->getType()) {
case scalar:
copyScalar(
static_cast<PVScalar *>(from),static_cast<PVScalar *>(to));
return;
case scalarArray: {
PVScalarArray *fromArray = static_cast<PVScalarArray *>(from);
PVScalarArray *toArray = static_cast<PVScalarArray *>(to);
int length = copyScalarArray(fromArray,0,toArray,0,fromArray->getLength());
if(toArray->getLength()!=length) toArray->setLength(length);
return;
}
case structure:
copyStructure(static_cast<PVStructure *>(from) ,
static_cast<PVStructure *>(to));
return;
case structureArray: {
PVStructureArray *fromArray = static_cast<PVStructureArray *>(from);
PVStructureArray *toArray = static_cast<PVStructureArray *>(to);
copyStructureArray(fromArray,toArray);
return;
}
}
}
bool Convert::isCopyScalarCompatible(
ScalarConstPtr fromField, ScalarConstPtr toField)
{
ScalarType fromScalarType = fromField->getScalarType();
ScalarType toScalarType = toField->getScalarType();
if(fromScalarType==toScalarType) return true;
if(ScalarTypeFunc::isNumeric(fromScalarType)
&& ScalarTypeFunc::isNumeric(toScalarType)) return true;
if(fromScalarType==pvString) return true;
if(toScalarType==pvString) return true;
return false;
}
void Convert::copyScalar(PVScalar *from, PVScalar *to)
{
if(to->isImmutable()) {
if(from==to) return;
String message("Convert.copyScalar destination is immutable");
throw std::invalid_argument(message);
}
ScalarType fromType = from->getScalar()->getScalarType();
ScalarType toType = to->getScalar()->getScalarType();
switch(fromType) {
case pvBoolean: {
if(toType!=pvBoolean) {
if(toType!=pvString) {
String message("Convert.copyScalar arguments are not compatible");
throw std::invalid_argument(message);
}
}
PVBoolean *data = static_cast<PVBoolean*>(from);
if(toType==pvString) {
PVString *dataTo = static_cast<PVString*>(to);
String buf("");
data->toString(&buf);
dataTo->put(buf);
} else {
bool value = data->get();
PVBoolean *dataTo = static_cast<PVBoolean*>(to);
dataTo->put(value);
}
return;
}
case pvByte : {
PVByte *data = static_cast<PVByte*>(from);
int8 value = data->get();
convert->fromByte(to,value);
return;
}
case pvShort : {
PVShort *data = static_cast<PVShort*>(from);
short value = data->get();
convert->fromShort(to,value);
return;
}
case pvInt :{
PVInt *data = static_cast<PVInt*>(from);
int value = data->get();
convert->fromInt(to,value);
return;
}
case pvLong : {
PVLong *data = static_cast<PVLong*>(from);
long value = data->get();
convert->fromLong(to,value);
return;
}
case pvFloat : {
PVFloat *data = static_cast<PVFloat*>(from);
float value = data->get();
convert->fromFloat(to,value);
return;
}
case pvDouble : {
PVDouble *data = static_cast<PVDouble*>(from);
double value = data->get();
convert->fromDouble(to,value);
return;
}
case pvString: {
PVString *data = static_cast<PVString*>(from);
String value = data->get();
convert->fromString(to,value);
return;
}
}
String message("Convert::copyScalar should never get here");
throw std::logic_error(message);
}
bool Convert::isCopyScalarArrayCompatible(ScalarArrayConstPtr fromArray,
ScalarArrayConstPtr toArray)
{
ScalarType fromType = fromArray->getElementType();
ScalarType toType = toArray->getElementType();
if(fromType==toType) return true;
if(ScalarTypeFunc::isNumeric(fromType)
&& ScalarTypeFunc::isNumeric(toType)) return true;
if(toType==pvString) return true;
if(fromType==pvString) return true;
return false;
}
int Convert::copyScalarArray(PVScalarArray *from, int offset,
PVScalarArray *to, int toOffset, int length)
{
if(to->isImmutable()) {
if(from==to) return from->getLength();
String message("Convert.copyArray destination is immutable");
throw std::invalid_argument(message);
}
ScalarType fromElementType = from->getScalarArray()->getElementType();
ScalarType toElementType = to->getScalarArray()->getElementType();
if(from->isImmutable() && (fromElementType==toElementType)) {
if(offset==0 && toOffset==0 && length==from->getLength()) {
return copyArrayDataReference(from,to);
}
}
int ncopy = 0;
if(ScalarTypeFunc::isNumeric(fromElementType)
&& ScalarTypeFunc::isNumeric(toElementType)) {
return copyNumericArray(from,offset,to,toOffset,length);
} else if(toElementType==pvBoolean && fromElementType==pvBoolean) {
PVBooleanArray *pvfrom = static_cast<PVBooleanArray*>(from);
PVBooleanArray *pvto = static_cast<PVBooleanArray*>(to);
while(length>0) {
int num = 0;
BooleanArray data = 0;
int fromOffset = 0;
BooleanArrayData booleanArrayData = BooleanArrayData();
num = pvfrom->get(offset,length,&booleanArrayData);
data = booleanArrayData.data;
fromOffset = booleanArrayData.offset;
if(num<=0) return ncopy;
while(num>0) {
int n = pvto->put(toOffset,num,data,fromOffset);
if(n<=0) return ncopy;
length -= n; num -= n; ncopy+=n; offset += n; toOffset += n;
}
}
return ncopy;
} else if(toElementType==pvString && fromElementType==pvString) {
PVStringArray *pvfrom = static_cast<PVStringArray*>(from);
PVStringArray *pvto = static_cast<PVStringArray*>(to);
while(length>0) {
int num = 0;
String *data;
int fromOffset = 0;
StringArrayData stringArrayData = StringArrayData();
num = pvfrom->get(offset,length,&stringArrayData);
data = stringArrayData.data;
fromOffset = stringArrayData.offset;
if(num<=0) return ncopy;
while(num>0) {
int n = pvto->put(toOffset,num,data,fromOffset);
if(n<=0) return ncopy;
length -= n; num -= n; ncopy+=n; offset += n; toOffset += n;
}
}
return ncopy;
} else if(toElementType==pvString) {
PVStringArray *pvto = static_cast<PVStringArray*>(to);
ncopy = from->getLength();
if(ncopy>length) ncopy = length;
int num = ncopy;
String toData[1];
while(num>0) {
convert->toStringArray(from,offset,1,toData,0);
if(pvto->put(toOffset,1,toData,0)<=0) break;
num--; offset++; toOffset++;
}
return ncopy;
} else if(fromElementType==pvString) {
PVStringArray *pvfrom = static_cast<PVStringArray*>(from);
while(length>0) {
int num = 0;
String *data = 0;
int fromOffset = 0;
StringArrayData stringArrayData = StringArrayData();
num = pvfrom->get(offset,length,&stringArrayData);
data = stringArrayData.data;
fromOffset = stringArrayData.offset;
if(num<=0) return ncopy;
while(num>0) {
int n = fromStringArray(to,toOffset,num,data,fromOffset);
if(n<=0) return ncopy;
length -= n; num -= n; ncopy+=n; offset += n; toOffset += n;
}
}
return ncopy;
}
String message("Convert::copyScalarArray should not get here");
throw std::logic_error(message);
}
bool Convert::isCopyStructureCompatible(
StructureConstPtr fromStruct, StructureConstPtr toStruct)
{
FieldConstPtrArray fromFields = fromStruct->getFields();
FieldConstPtrArray toFields = toStruct->getFields();
int length = fromStruct->getNumberFields();
if(length!=toStruct->getNumberFields()) return false;
for(int i=0; i<length; i++) {
FieldConstPtr from = fromFields[i];
FieldConstPtr to = toFields[i];
Type fromType = from->getType();
Type toType = to->getType();
if(fromType!=toType) return false;
switch(fromType) {
case scalar:
if(!convert->isCopyScalarCompatible(
static_cast<ScalarConstPtr>(from),
static_cast<ScalarConstPtr>(to)))
return false;
break;
case scalarArray:
if(!isCopyScalarArrayCompatible(
static_cast<ScalarArrayConstPtr>(from),
static_cast<ScalarArrayConstPtr>(to)))
return false;
break;
case structure:
if(!isCopyStructureCompatible(
static_cast<StructureConstPtr>(from),
static_cast<StructureConstPtr>(to)))
return false;
break;
case structureArray:
if(!isCopyStructureArrayCompatible(
static_cast<StructureArrayConstPtr>(from),
static_cast<StructureArrayConstPtr>(to)))
return false;
}
}
return true;
}
void Convert::copyStructure(PVStructure *from, PVStructure *to)
{
if(to->isImmutable()) {
if(from==to) return;
String message("Convert.copyStructure destination is immutable");
throw std::invalid_argument(message);
}
if(from==to) return;
PVFieldPtrArray fromDatas = from->getPVFields();
PVFieldPtrArray toDatas = to->getPVFields();
if(from->getStructure()->getNumberFields()
!= to->getStructure()->getNumberFields()) {
String message("Convert.copyStructure Illegal copyStructure");
throw std::invalid_argument(message);
}
int numberFields = from->getStructure()->getNumberFields();
if(numberFields==2) {
// look for enumerated structure and copy choices first
String fieldName = fromDatas[0]->getField()->getFieldName();
if(fieldName.compare("index")==0) {
FieldConstPtr fieldIndex = fromDatas[0]->getField();
FieldConstPtr fieldChoices = fromDatas[1]->getField();
if(fieldIndex->getType()==scalar
&& (fieldChoices->getFieldName().compare("choices")==0)
&& fieldChoices->getType()==scalarArray) {
PVScalar *pvScalar = static_cast<PVScalar*>(fromDatas[0]);
PVScalarArray *pvArray =
static_cast<PVScalarArray*>(fromDatas[1]);
if((pvScalar->getScalar()->getScalarType()==pvInt)
&& (pvArray->getScalarArray()->getElementType()==pvString)) {
PVScalarArray* toArray =
static_cast<PVScalarArray*>(toDatas[1]);
copyScalarArray(pvArray,0,toArray,0,pvArray->getLength());
PVScalar *toScalar = static_cast<PVScalar*>(toDatas[0]);
copyScalar(pvScalar,toScalar);
return;
}
}
}
}
for(int i=0; i < numberFields; i++) {
PVField *fromData = fromDatas[i];
PVField *toData = toDatas[i];
Type fromType = fromData->getField()->getType();
Type toType = toData->getField()->getType();
if(fromType!=toType) {
String message("Convert.copyStructure Illegal copyStructure");
throw std::invalid_argument(message);
}
switch(fromType) {
case scalar:
copyScalar(
static_cast<PVScalar*>(fromData),
static_cast<PVScalar*>(toData));
break;
case scalarArray: {
PVScalarArray *fromArray = static_cast<PVScalarArray*>(fromData);
PVScalarArray *toArray = static_cast<PVScalarArray*>(toData);
int length = copyScalarArray(
fromArray,0,toArray,0,fromArray->getLength());
if(toArray->getLength()!=length) toArray->setLength(length);
break;
}
case structure:
copyStructure(
static_cast<PVStructure*>(fromData),
static_cast<PVStructure*>(toData));
break;
case structureArray: {
PVStructureArray *fromArray =
static_cast<PVStructureArray*>(fromData);
PVStructureArray *toArray =
static_cast<PVStructureArray*>(toData);
copyStructureArray(fromArray,toArray);
break;
}
}
}
}
bool Convert::isCopyStructureArrayCompatible(
StructureArrayConstPtr from, StructureArrayConstPtr to)
{
return isCopyStructureCompatible(from->getStructure(),to->getStructure());
}
void Convert::copyStructureArray(
PVStructureArray *from, PVStructureArray *to)
{
if(to->isImmutable()) {
if(from==to) return;
String message("Convert.copyStructureArray destination is immutable");
throw std::invalid_argument(message);
}
if(!isCopyStructureCompatible(
from->getStructureArray()->getStructure(),
to->getStructureArray()->getStructure())) {
String message("Convert.copyStructureArray from and to are not compatible");
throw std::invalid_argument(message);
}
PVStructurePtrArray fromArray = 0;
int length = from->getLength();
StructureArrayData structureArrayData = StructureArrayData();
from->get(0, length,&structureArrayData);
fromArray = structureArrayData.data;
PVStructurePtrArray toArray = 0;
if(to->getCapacity()<length) to->setCapacity(length);
to->get(0, length,&structureArrayData);
toArray = structureArrayData.data;
for(int i=0; i<length; i++) {
if(fromArray[i]==0) {
if(toArray[i]!=0) delete toArray[i];
toArray[i] = 0;
} else {
if(toArray[i]==0) {
StructureConstPtr structure = to->getStructureArray()->getStructure();
toArray[i] = pvDataCreate->createPVStructure(0,structure);
}
copyStructure(fromArray[i],toArray[i]);
}
}
to->setLength(length);
to->postPut();
}
int8 Convert::toByte(PVScalar * pv)
{
ScalarConstPtr scalar = pv->getScalar();
ScalarType scalarType = scalar->getScalarType();
switch(scalarType) {
case pvBoolean:
throw std::logic_error(String("boolean can not be converted to byte"));
case pvByte: {
PVByte *value = static_cast<PVByte *>(pv);
return value->get();
}
case pvShort: {
PVShort *value = static_cast<PVShort *>(pv);
return value->get();
}
case pvInt: {
PVInt *value = static_cast<PVInt *>(pv);
return value->get();
}
case pvLong: {
PVLong *value = static_cast<PVLong *>(pv);
return value->get();
}
case pvFloat: {
PVFloat *value = static_cast<PVFloat *>(pv);
return value->get();
}
case pvDouble: {
PVDouble *value = static_cast<PVDouble *>(pv);
return value->get();
}
case pvString:
throw std::logic_error(String("string can not be converted to byte"));
}
throw std::logic_error(logicError);
}
int16 Convert::toShort(PVScalar * pv)
{
ScalarConstPtr scalar = pv->getScalar();
ScalarType scalarType = scalar->getScalarType();
switch(scalarType) {
case pvBoolean:
throw std::logic_error(String("boolean can not be converted to short"));
case pvByte: {
PVByte *value = static_cast<PVByte *>(pv);
return value->get();
}
case pvShort: {
PVShort *value = static_cast<PVShort *>(pv);
return value->get();
}
case pvInt: {
PVInt *value = static_cast<PVInt *>(pv);
return value->get();
}
case pvLong: {
PVLong *value = static_cast<PVLong *>(pv);
return value->get();
}
case pvFloat: {
PVFloat *value = static_cast<PVFloat *>(pv);
return value->get();
}
case pvDouble: {
PVDouble *value = static_cast<PVDouble *>(pv);
return value->get();
}
case pvString:
throw std::logic_error(String("string can not be converted to short"));
}
throw std::logic_error(logicError);
}
int32 Convert::toInt(PVScalar * pv)
{
ScalarConstPtr scalar = pv->getScalar();
ScalarType scalarType = scalar->getScalarType();
switch(scalarType) {
case pvBoolean:
throw std::logic_error(String("boolean can not be converted to int"));
case pvByte: {
PVByte *value = static_cast<PVByte *>(pv);
return value->get();
}
case pvShort: {
PVShort *value = static_cast<PVShort *>(pv);
return value->get();
}
case pvInt: {
PVInt *value = static_cast<PVInt *>(pv);
return value->get();
}
case pvLong: {
PVLong *value = static_cast<PVLong *>(pv);
return value->get();
}
case pvFloat: {
PVFloat *value = static_cast<PVFloat *>(pv);
return value->get();
}
case pvDouble: {
PVDouble *value = static_cast<PVDouble *>(pv);
return value->get();
}
case pvString:
throw std::logic_error(String("string can not be converted to int"));
}
throw std::logic_error(logicError);
}
int64 Convert::toLong(PVScalar * pv)
{
ScalarConstPtr scalar = pv->getScalar();
ScalarType scalarType = scalar->getScalarType();
switch(scalarType) {
case pvBoolean:
throw std::logic_error(String("boolean can not be converted to long"));
case pvByte: {
PVByte *value = static_cast<PVByte *>(pv);
return value->get();
}
case pvShort: {
PVShort *value = static_cast<PVShort *>(pv);
return value->get();
}
case pvInt: {
PVInt *value = static_cast<PVInt *>(pv);
return value->get();
}
case pvLong: {
PVLong *value = static_cast<PVLong *>(pv);
return value->get();
}
case pvFloat: {
PVFloat *value = static_cast<PVFloat *>(pv);
return value->get();
}
case pvDouble: {
PVDouble *value = static_cast<PVDouble *>(pv);
return value->get();
}
case pvString:
throw std::logic_error(String("string can not be converted to long"));
}
throw std::logic_error(logicError);
}
float Convert::toFloat(PVScalar * pv)
{
ScalarConstPtr scalar = pv->getScalar();
ScalarType scalarType = scalar->getScalarType();
switch(scalarType) {
case pvBoolean:
throw std::logic_error(String("boolean can not be converted to float"));
case pvByte: {
PVByte *value = static_cast<PVByte *>(pv);
return value->get();
}
case pvShort: {
PVShort *value = static_cast<PVShort *>(pv);
return value->get();
}
case pvInt: {
PVInt *value = static_cast<PVInt *>(pv);
return value->get();
}
case pvLong: {
PVLong *value = static_cast<PVLong *>(pv);
return value->get();
}
case pvFloat: {
PVFloat *value = static_cast<PVFloat *>(pv);
return value->get();
}
case pvDouble: {
PVDouble *value = static_cast<PVDouble *>(pv);
return value->get();
}
case pvString:
throw std::logic_error(String("string can not be converted to float"));
}
throw std::logic_error(logicError);
}
double Convert::toDouble(PVScalar * pv)
{
ScalarConstPtr scalar = pv->getScalar();
ScalarType scalarType = scalar->getScalarType();
switch(scalarType) {
case pvBoolean:
throw std::logic_error(String("boolean can not be converted to double"));
case pvByte: {
PVByte *value = static_cast<PVByte *>(pv);
return value->get();
}
case pvShort: {
PVShort *value = static_cast<PVShort *>(pv);
return value->get();
}
case pvInt: {
PVInt *value = static_cast<PVInt *>(pv);
return value->get();
}
case pvLong: {
PVLong *value = static_cast<PVLong *>(pv);
return value->get();
}
case pvFloat: {
PVFloat *value = static_cast<PVFloat *>(pv);
return value->get();
}
case pvDouble: {
PVDouble *value = static_cast<PVDouble *>(pv);
return value->get();
}
case pvString:
throw std::logic_error(String("string can not be converted to double"));
}
throw std::logic_error(logicError);
}
String Convert::toString(PVScalar * pv)
{
static String trueString("true");
static String falseString("false");
ScalarConstPtr scalar = pv->getScalar();
ScalarType scalarType = scalar->getScalarType();
switch(scalarType) {
case pvBoolean: {
PVBoolean *pvalue = static_cast<PVBoolean *>(pv);
bool value = pvalue->get();
return value ? trueString : falseString;
}
case pvByte: {
PVByte *value = static_cast<PVByte *>(pv);
char buffer[30];
sprintf(buffer,"%d",(int)value->get());
return String(buffer);
}
case pvShort: {
PVShort *value = static_cast<PVShort *>(pv);
char buffer[30];
sprintf(buffer,"%d",(int)value->get());
return String(buffer);
}
case pvInt: {
PVInt *value = static_cast<PVInt *>(pv);
char buffer[30];
sprintf(buffer,"%d",value->get());
return String(buffer);
}
case pvLong: {
PVLong *value = static_cast<PVLong *>(pv);
char buffer[30];
sprintf(buffer,"%lli",value->get());
return String(buffer);
}
case pvFloat: {
PVFloat *value = static_cast<PVFloat *>(pv);
char buffer[30];
sprintf(buffer,"%g",value->get());
return String(buffer);
}
case pvDouble: {
PVDouble *value = static_cast<PVDouble *>(pv);
char buffer[30];
sprintf(buffer,"%lg",value->get());
return String(buffer);
}
case pvString: {
PVString *value = static_cast<PVString *>(pv);
return value->get();
}
}
throw std::logic_error(logicError);
}
void Convert::fromByte(PVScalar *pv,int8 from)
{
ScalarConstPtr scalar = pv->getScalar();
ScalarType scalarType = scalar->getScalarType();
switch(scalarType) {
case pvBoolean:
throw std::logic_error(String("byte can not be converted to boolean"));
case pvByte: {
PVByte *value = static_cast<PVByte *>(pv);
value->put(from); return;
}
case pvShort: {
PVShort *value = static_cast<PVShort *>(pv);
value->put(from); return;
}
case pvInt: {
PVInt *value = static_cast<PVInt *>(pv);
value->put(from); return;
}
case pvLong: {
PVLong *value = static_cast<PVLong *>(pv);
value->put(from); return;
}
case pvFloat: {
PVFloat *value = static_cast<PVFloat *>(pv);
value->put(from); return;
}
case pvDouble: {
PVDouble *value = static_cast<PVDouble *>(pv);
value->put(from); return;
}
case pvString: {
PVString *value = static_cast<PVString *>(pv);
char buffer[20];
int ival = from;
sprintf(buffer,"%d",ival);
String xxx(buffer);
value->put(xxx);
return;
}
}
throw std::logic_error(logicError);
}
void Convert::fromShort(PVScalar *pv,int16 from)
{
ScalarConstPtr scalar = pv->getScalar();
ScalarType scalarType = scalar->getScalarType();
switch(scalarType) {
case pvBoolean:
throw std::logic_error(String("short can not be converted to boolean"));
case pvByte: {
PVByte *value = static_cast<PVByte *>(pv);
value->put(from); return;
}
case pvShort: {
PVShort *value = static_cast<PVShort *>(pv);
value->put(from); return;
}
case pvInt: {
PVInt *value = static_cast<PVInt *>(pv);
value->put(from); return;
}
case pvLong: {
PVLong *value = static_cast<PVLong *>(pv);
value->put(from); return;
}
case pvFloat: {
PVFloat *value = static_cast<PVFloat *>(pv);
value->put(from); return;
}
case pvDouble: {
PVDouble *value = static_cast<PVDouble *>(pv);
value->put(from); return;
}
case pvString: {
PVString *value = static_cast<PVString *>(pv);
char buffer[20];
int ival = from;
sprintf(buffer,"%d",ival);
String xxx(buffer);
value->put(xxx);
return;
}
}
throw std::logic_error(logicError);
}
void Convert::fromInt(PVScalar *pv, int32 from)
{
ScalarConstPtr scalar = pv->getScalar();
ScalarType scalarType = scalar->getScalarType();
switch(scalarType) {
case pvBoolean:
throw std::logic_error(String("int can not be converted to boolean"));
case pvByte: {
PVByte *value = static_cast<PVByte *>(pv);
value->put(from); return;
}
case pvShort: {
PVShort *value = static_cast<PVShort *>(pv);
value->put(from); return;
}
case pvInt: {
PVInt *value = static_cast<PVInt *>(pv);
value->put(from); return;
}
case pvLong: {
PVLong *value = static_cast<PVLong *>(pv);
value->put(from); return;
}
case pvFloat: {
PVFloat *value = static_cast<PVFloat *>(pv);
value->put(from); return;
}
case pvDouble: {
PVDouble *value = static_cast<PVDouble *>(pv);
value->put(from); return;
}
case pvString: {
PVString *value = static_cast<PVString *>(pv);
char buffer[20];
int ival = from;
sprintf(buffer,"%d",ival);
String xxx(buffer);
value->put(xxx);
return;
}
}
throw std::logic_error(logicError);
}
void Convert::fromLong(PVScalar *pv, int64 from)
{
ScalarConstPtr scalar = pv->getScalar();
ScalarType scalarType = scalar->getScalarType();
switch(scalarType) {
case pvBoolean:
throw std::logic_error(String("long can not be converted to boolean"));
case pvByte: {
PVByte *value = static_cast<PVByte *>(pv);
value->put(from); return;
}
case pvShort: {
PVShort *value = static_cast<PVShort *>(pv);
value->put(from); return;
}
case pvInt: {
PVInt *value = static_cast<PVInt *>(pv);
value->put(from); return;
}
case pvLong: {
PVLong *value = static_cast<PVLong *>(pv);
value->put(from); return;
}
case pvFloat: {
PVFloat *value = static_cast<PVFloat *>(pv);
value->put(from); return;
}
case pvDouble: {
PVDouble *value = static_cast<PVDouble *>(pv);
value->put(from); return;
}
case pvString: {
PVString *value = static_cast<PVString *>(pv);
char buffer[20];
int64 ival = from;
sprintf(buffer,"%lld",ival);
String xxx(buffer);
value->put(xxx);
return;
}
}
throw std::logic_error(logicError);
}
void Convert::fromFloat(PVScalar* pv, float from)
{
ScalarConstPtr scalar = pv->getScalar();
ScalarType scalarType = scalar->getScalarType();
switch(scalarType) {
case pvBoolean:
throw std::logic_error(String("float can not be converted to boolean"));
case pvByte: {
PVByte *value = static_cast<PVByte *>(pv);
value->put(from); return;
}
case pvShort: {
PVShort *value = static_cast<PVShort *>(pv);
value->put(from); return;
}
case pvInt: {
PVInt *value = static_cast<PVInt *>(pv);
value->put(from); return;
}
case pvLong: {
PVLong *value = static_cast<PVLong *>(pv);
value->put(from); return;
}
case pvFloat: {
PVFloat *value = static_cast<PVFloat *>(pv);
value->put(from); return;
}
case pvDouble: {
PVDouble *value = static_cast<PVDouble *>(pv);
value->put(from); return;
}
case pvString: {
PVString *value = static_cast<PVString *>(pv);
char buffer[20];
double dval = from;
sprintf(buffer,"%g",dval);
String xxx(buffer);
value->put(xxx);
return;
}
}
throw std::logic_error(logicError);
}
void Convert::fromDouble(PVScalar *pv, double from)
{
ScalarConstPtr scalar = pv->getScalar();
ScalarType scalarType = scalar->getScalarType();
switch(scalarType) {
case pvBoolean:
throw std::logic_error(String("double can not be converted to boolean"));
case pvByte: {
PVByte *value = static_cast<PVByte *>(pv);
value->put(from); return;
}
case pvShort: {
PVShort *value = static_cast<PVShort *>(pv);
value->put(from); return;
}
case pvInt: {
PVInt *value = static_cast<PVInt *>(pv);
value->put(from); return;
}
case pvLong: {
PVLong *value = static_cast<PVLong *>(pv);
value->put(from); return;
}
case pvFloat: {
PVFloat *value = static_cast<PVFloat *>(pv);
value->put(from); return;
}
case pvDouble: {
PVDouble *value = static_cast<PVDouble *>(pv);
value->put(from); return;
}
case pvString: {
PVString *value = static_cast<PVString *>(pv);
char buffer[20];
double dval = from;
sprintf(buffer,"%g",dval);
String xxx(buffer);
value->put(xxx);
return;
}
}
throw std::logic_error(logicError);
}
int Convert::toByteArray(PVScalarArray * pv, int offset, int length,
int8 to[], int toOffset)
{
return convertToByteArray(pv, offset, length, to, toOffset);
}
int Convert::toShortArray(PVScalarArray * pv, int offset, int length,
int16 to[], int toOffset)
{
return convertToShortArray(pv, offset, length, to, toOffset);
}
int Convert::toIntArray(PVScalarArray * pv, int offset, int length,
int32 to[], int toOffset)
{
return convertToIntArray(pv, offset, length, to, toOffset);
}
int Convert::toLongArray(PVScalarArray * pv, int offset, int length,
int64 to[], int toOffset)
{
return convertToLongArray(pv, offset, length, to, toOffset);
}
int Convert::toFloatArray(PVScalarArray * pv, int offset, int length,
float to[], int toOffset)
{
return convertToFloatArray(pv, offset, length, to, toOffset);
}
int Convert::toDoubleArray(PVScalarArray * pv, int offset, int length,
double to[], int toOffset)
{
return convertToDoubleArray(pv, offset, length, to, toOffset);
}
int Convert::fromByteArray(PVScalarArray *pv, int offset, int length,
int8 from[], int fromOffset)
{
return convertFromByteArray(pv, offset, length, from, fromOffset);
}
int Convert::fromShortArray(PVScalarArray *pv, int offset, int length,
int16 from[], int fromOffset)
{
return convertFromShortArray(pv, offset, length, from, fromOffset);
}
int Convert::fromIntArray(PVScalarArray *pv, int offset, int length,
int32 from[], int fromOffset)
{
return convertFromIntArray(pv, offset, length, from, fromOffset);
}
int Convert::fromLongArray(PVScalarArray *pv, int offset, int length,
int64 from[], int fromOffset)
{
return convertFromLongArray(pv, offset, length, from, fromOffset);
}
int Convert::fromFloatArray(PVScalarArray *pv, int offset, int length,
float from[], int fromOffset)
{
return convertFromFloatArray(pv, offset, length, from, fromOffset);
}
int Convert::fromDoubleArray(PVScalarArray *pv, int offset, int length,
double from[], int fromOffset)
{
return convertFromDoubleArray(pv, offset, length, from, fromOffset);
}
void Convert::newLine(StringBuilder buffer, int indentLevel)
{
*buffer += "\n";
for(int i=0; i<indentLevel; i++) *buffer += " ";
}
static bool scalarEquals(PVScalar *a,PVScalar *b)
{
ScalarType ascalarType = a->getScalar()->getScalarType();
ScalarType bscalarType = b->getScalar()->getScalarType();
if(ascalarType!=bscalarType) return false;
switch(ascalarType) {
case pvBoolean: {
PVBoolean *pa = static_cast<PVBoolean *>(a);
PVBoolean *pb = static_cast<PVBoolean *>(b);
bool avalue = pa->get();
bool bvalue = pb->get();
return ((avalue==bvalue) ? true : false);
}
case pvByte: {
PVByte *pa = static_cast<PVByte *>(a);
PVByte *pb = static_cast<PVByte *>(b);
int8 avalue = pa->get();
int8 bvalue = pb->get();
return ((avalue==bvalue) ? true : false);
}
case pvShort: {
PVShort *pa = static_cast<PVShort *>(a);
PVShort *pb = static_cast<PVShort *>(b);
int16 avalue = pa->get();
int16 bvalue = pb->get();
return ((avalue==bvalue) ? true : false);
}
case pvInt: {
PVInt *pa = static_cast<PVInt *>(a);
PVInt *pb = static_cast<PVInt *>(b);
int32 avalue = pa->get();
int32 bvalue = pb->get();
return ((avalue==bvalue) ? true : false);
}
case pvLong: {
PVLong *pa = static_cast<PVLong *>(a);
PVLong *pb = static_cast<PVLong *>(b);
int64 avalue = pa->get();
int64 bvalue = pb->get();
return ((avalue==bvalue) ? true : false);
}
case pvFloat: {
PVFloat *pa = static_cast<PVFloat *>(a);
PVFloat *pb = static_cast<PVFloat *>(b);
float avalue = pa->get();
float bvalue = pb->get();
return ((avalue==bvalue) ? true : false);
}
case pvDouble: {
PVDouble *pa = static_cast<PVDouble *>(a);
PVDouble *pb = static_cast<PVDouble *>(b);
double avalue = pa->get();
double bvalue = pb->get();
return ((avalue==bvalue) ? true : false);
}
case pvString: {
PVString *pa = static_cast<PVString *>(a);
PVString *pb = static_cast<PVString *>(b);
String avalue = pa->get();
String bvalue = pb->get();
return ((avalue==bvalue) ? true : false);
}
}
String message("should not get here");
throw std::logic_error(message);
}
static bool arrayEquals(PVScalarArray *a,PVScalarArray *b)
{
if(a==b) return true;
ScalarType aType = a->getScalarArray()->getElementType();
ScalarType bType = b->getScalarArray()->getElementType();
if(aType!=bType) return false;
if(a->getLength()!=b->getLength()) return false;
int length = a->getLength();
switch(aType) {
case pvBoolean: {
PVBooleanArray *aarray = static_cast<PVBooleanArray *>(a);
PVBooleanArray *barray = static_cast<PVBooleanArray *>(b);
BooleanArrayData adata = BooleanArrayData();
BooleanArrayData bdata = BooleanArrayData();
aarray->get(0,length,&adata);
barray->get(0,length,&bdata);
BooleanArray avalue = adata.data;
BooleanArray bvalue = bdata.data;
for(int i=0; i<length; i++) {
if(avalue[i]!=bvalue[i]) return false;
}
return true;
}
case pvByte: {
PVByteArray *aarray = static_cast<PVByteArray *>(a);
PVByteArray *barray = static_cast<PVByteArray *>(b);
ByteArrayData adata = ByteArrayData();
ByteArrayData bdata = ByteArrayData();
aarray->get(0,length,&adata);
barray->get(0,length,&bdata);
ByteArray avalue = adata.data;
ByteArray bvalue = bdata.data;
for(int i=0; i<length; i++) {
if(avalue[i]!=bvalue[i]) return false;
}
return true;
}
case pvShort: {
PVShortArray *aarray = static_cast<PVShortArray *>(a);
PVShortArray *barray = static_cast<PVShortArray *>(b);
ShortArrayData adata = ShortArrayData();
ShortArrayData bdata = ShortArrayData();
aarray->get(0,length,&adata);
barray->get(0,length,&bdata);
ShortArray avalue = adata.data;
ShortArray bvalue = bdata.data;
for(int i=0; i<length; i++) {
if(avalue[i]!=bvalue[i]) return false;
}
return true;
}
case pvInt: {
PVIntArray *aarray = static_cast<PVIntArray *>(a);
PVIntArray *barray = static_cast<PVIntArray *>(b);
IntArrayData adata = IntArrayData();
IntArrayData bdata = IntArrayData();
aarray->get(0,length,&adata);
barray->get(0,length,&bdata);
IntArray avalue = adata.data;
IntArray bvalue = bdata.data;
for(int i=0; i<length; i++) {
if(avalue[i]!=bvalue[i]) return false;
}
return true;
}
case pvLong: {
PVLongArray *aarray = static_cast<PVLongArray *>(a);
PVLongArray *barray = static_cast<PVLongArray *>(b);
LongArrayData adata = LongArrayData();
LongArrayData bdata = LongArrayData();
aarray->get(0,length,&adata);
barray->get(0,length,&bdata);
LongArray avalue = adata.data;
LongArray bvalue = bdata.data;
for(int i=0; i<length; i++) {
if(avalue[i]!=bvalue[i]) return false;
}
return true;
}
case pvFloat: {
PVFloatArray *aarray = static_cast<PVFloatArray *>(a);
PVFloatArray *barray = static_cast<PVFloatArray *>(b);
FloatArrayData adata = FloatArrayData();
FloatArrayData bdata = FloatArrayData();
aarray->get(0,length,&adata);
barray->get(0,length,&bdata);
FloatArray avalue = adata.data;
FloatArray bvalue = bdata.data;
for(int i=0; i<length; i++) {
if(avalue[i]!=bvalue[i]) return false;
}
return true;
}
case pvDouble: {
PVDoubleArray *aarray = static_cast<PVDoubleArray *>(a);
PVDoubleArray *barray = static_cast<PVDoubleArray *>(b);
DoubleArrayData adata = DoubleArrayData();
DoubleArrayData bdata = DoubleArrayData();
aarray->get(0,length,&adata);
barray->get(0,length,&bdata);
DoubleArray avalue = adata.data;
DoubleArray bvalue = bdata.data;
for(int i=0; i<length; i++) {
if(avalue[i]!=bvalue[i]) return false;
}
return true;
}
case pvString: {
PVStringArray *aarray = static_cast<PVStringArray *>(a);
PVStringArray *barray = static_cast<PVStringArray *>(b);
StringArrayData adata = StringArrayData();
StringArrayData bdata = StringArrayData();
aarray->get(0,length,&adata);
barray->get(0,length,&bdata);
String *avalue = adata.data;
String *bvalue = bdata.data;
for(int i=0; i<length; i++) {
if(avalue[i]!=bvalue[i]) return false;
}
return true;
}
}
String message("should not get here");
throw std::logic_error(message);
}
static bool structureArrayEquals(PVStructureArray *a,PVStructureArray *b)
{
StructureConstPtr aStructure = a->getStructureArray()->getStructure();
StructureConstPtr bStructure = b->getStructureArray()->getStructure();
if(aStructure!=bStructure) return false;
if(a->getLength()!=b->getLength()) return false;
StructureArrayData aData = StructureArrayData();
StructureArrayData bData = StructureArrayData();
int length = a->getLength();
PVStructurePtrArray aArray = aData.data;
PVStructurePtrArray bArray = bData.data;
if(aArray==bArray) return true;
for(int i=0; i<length; i++) {
if(aArray[i]==0) {
if(bArray[i]==0) continue;
return false;
} else {
if(bArray[i]==0) return false;
}
if(*aArray[i]!=*bArray[i]) return false;
}
return true;
}
static bool structureEquals(PVStructure *a,PVStructure *b)
{
StructureConstPtr aStructure = a->getStructure();
StructureConstPtr bStructure = a->getStructure();
int length = aStructure->getNumberFields();
if(length!=bStructure->getNumberFields()) return false;
PVFieldPtrArray aFields = a->getPVFields();
PVFieldPtrArray bFields = b->getPVFields();
for(int i=0; i<length; i++) {
if(*aFields[i]!=*bFields[i]) return false;
}
return true;
}
bool convertEquals(PVField *a,PVField *b)
{
void * avoid = static_cast<void *>(a);
void * bvoid = static_cast<void *>(b);
if(avoid==bvoid) return true;
Type atype = a->getField()->getType();
Type btype = b->getField()->getType();
if(atype!=btype) return false;
if(atype==scalar) return scalarEquals(
static_cast<PVScalar *>(a),static_cast<PVScalar *>(b));
if(atype==scalarArray) return arrayEquals(
static_cast<PVScalarArray *>(a),static_cast<PVScalarArray *>(b));
if(atype==structureArray) return structureArrayEquals(
static_cast<PVStructureArray *>(a),static_cast<PVStructureArray *>(b));
if(atype==structure) return structureEquals(
static_cast<PVStructure *>(a),static_cast<PVStructure *>(b));
String message("should not get here");
throw std::logic_error(message);
}
int convertFromByteArray(PVScalarArray *pv, int offset, int len,int8 from[], int fromOffset)
{
ScalarType elemType = pv->getScalarArray()->getElementType();
int ntransfered = 0;
switch (elemType) {
case pvBoolean: {
String message("convert from byte[] to BooleanArray not legal");
throw std::invalid_argument(message);
}
case pvByte: {
PVByteArray *pvdata = static_cast<PVByteArray*>(pv);
while (len > 0) {
int n = pvdata->put(offset, len, from, fromOffset);
if (n == 0)
break;
len -= n;
offset += n;
fromOffset += n;
ntransfered += n;
}
return ntransfered;
}
case pvShort: {
PVShortArray *pvdata = static_cast<PVShortArray*>(pv);
int16 data[1];
while (len > 0) {
data[0] = 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] = 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] = 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] = 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] = 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);
}
int convertToByteArray(PVScalarArray * pv, int offset, int len,int8 to[], int toOffset)
{
ScalarType elemType = pv->getScalarArray()->getElementType();
int 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 = ByteArrayData();
while (len > 0) {
int num = 0;
num = pvdata->get(offset,len,&data);
if (num <= 0) break;
ByteArray dataArray = data.data;
int dataOffset = data.offset;
for(int 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 = ShortArrayData();
while (len > 0) {
int num = pvdata->get(offset, len, &data);
if (num == 0) break;
ShortArray dataArray = data.data;
int dataOffset = data.offset;
for (int 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 = IntArrayData();
while (len > 0) {
int num = pvdata->get(offset, len, &data);
if (num == 0) break;
IntArray dataArray = data.data;
int dataOffset = data.offset;
for (int 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 = LongArrayData();
while (len > 0) {
int num = pvdata->get(offset, len, &data);
if (num == 0)
break;
LongArray dataArray = data.data;
int dataOffset = data.offset;
for (int 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 = FloatArrayData();
while (len > 0) {
int num = pvdata->get(offset, len, &data);
if (num == 0) break;
FloatArray dataArray = data.data;
int dataOffset = data.offset;
for (int i = 0; i < num; i++)
to[i + toOffset] = dataArray[i + dataOffset];
len -= num;
offset += num;
toOffset += num;
ntransfered += num;
}
return ntransfered;
}
case pvDouble: {
PVDoubleArray *pvdata = static_cast<PVDoubleArray*>(pv);
DoubleArrayData data = DoubleArrayData();
while (len > 0) {
int num = pvdata->get(offset, len, &data);
if (num == 0)
break;
DoubleArray dataArray = data.data;
int dataOffset = data.offset;
for (int i = 0; i < num; i++)
to[i + toOffset] = dataArray[i + dataOffset];
len -= num;
offset += num;
toOffset += num;
ntransfered += num;
}
return ntransfered;
}
case pvString: {
String message("convert StringArray to byte[]] not legal");
throw std::invalid_argument(message);
}
}
String message("Convert::convertToByteArray should never get here");
throw std::logic_error(message);
}
int convertFromShortArray(PVScalarArray *pv, int offset, int len,int16 from[], int fromOffset)
{
ScalarType elemType = pv->getScalarArray()->getElementType();
int ntransfered = 0;
switch (elemType) {
case pvBoolean: {
String message("convert from short[] 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] = 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);
while (len > 0) {
int n = pvdata->put(offset, len, from, fromOffset);
if (n == 0)
break;
len -= n;
offset += n;
fromOffset += n;
ntransfered += n;
}
return ntransfered;
}
case pvInt: {
PVIntArray *pvdata = static_cast<PVIntArray*>(pv);
int32 data[1];
while (len > 0) {
data[0] = 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] = 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] = 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] = from[fromOffset];
if (pvdata->put(offset, 1, data, 0) == 0)
return ntransfered;
--len;
++ntransfered;
++offset;
++fromOffset;
}
return ntransfered;
}
case pvString: {
String message("convert from short[] to StringArray not legal");
throw std::invalid_argument(message);
}
}
String message("Convert::convertFromShortArray should never get here");
throw std::logic_error(message);
}
int convertToShortArray(PVScalarArray * pv, int offset, int len,int16 to[], int toOffset)
{
ScalarType elemType = pv->getScalarArray()->getElementType();
int ntransfered = 0;
switch (elemType) {
case pvBoolean: {
String message("convert BooleanArray to short[]] not legal");
throw std::invalid_argument(message);
}
case pvByte: {
PVByteArray *pvdata = static_cast<PVByteArray*>(pv);
ByteArrayData data = ByteArrayData();
while (len > 0) {
int num = 0;
num = pvdata->get(offset,len,&data);
if (num <= 0) break;
ByteArray dataArray = data.data;
int dataOffset = data.offset;
for(int 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 = ShortArrayData();
while (len > 0) {
int num = pvdata->get(offset, len, &data);
if (num == 0) break;
ShortArray dataArray = data.data;
int dataOffset = data.offset;
for (int 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 = IntArrayData();
while (len > 0) {
int num = pvdata->get(offset, len, &data);
if (num == 0) break;
IntArray dataArray = data.data;
int dataOffset = data.offset;
for (int 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 = LongArrayData();
while (len > 0) {
int num = pvdata->get(offset, len, &data);
if (num == 0)
break;
LongArray dataArray = data.data;
int dataOffset = data.offset;
for (int 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 = FloatArrayData();
while (len > 0) {
int num = pvdata->get(offset, len, &data);
if (num == 0) break;
FloatArray dataArray = data.data;
int dataOffset = data.offset;
for (int i = 0; i < num; i++)
to[i + toOffset] = dataArray[i + dataOffset];
len -= num;
offset += num;
toOffset += num;
ntransfered += num;
}
return ntransfered;
}
case pvDouble: {
PVDoubleArray *pvdata = static_cast<PVDoubleArray*>(pv);
DoubleArrayData data = DoubleArrayData();
while (len > 0) {
int num = pvdata->get(offset, len, &data);
if (num == 0)
break;
DoubleArray dataArray = data.data;
int dataOffset = data.offset;
for (int i = 0; i < num; i++)
to[i + toOffset] = dataArray[i + dataOffset];
len -= num;
offset += num;
toOffset += num;
ntransfered += num;
}
return ntransfered;
}
case pvString: {
String message("convert StringArray to short[]] not legal");
throw std::invalid_argument(message);
}
}
String message("Convert::convertToShortArray should never get here");
throw std::logic_error(message);
}
int convertFromIntArray(PVScalarArray *pv, int offset, int len,int32 from[], int fromOffset)
{
ScalarType elemType = pv->getScalarArray()->getElementType();
int ntransfered = 0;
switch (elemType) {
case pvBoolean: {
String message("convert from int[] 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] = 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] = 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);
while (len > 0) {
int n = pvdata->put(offset, len, from, fromOffset);
if (n == 0)
break;
len -= n;
offset += n;
fromOffset += n;
ntransfered += n;
}
return ntransfered;
}
case pvLong: {
PVLongArray *pvdata = static_cast<PVLongArray*>(pv);
int64 data[1];
while (len > 0) {
data[0] = 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] = 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] = from[fromOffset];
if (pvdata->put(offset, 1, data, 0) == 0)
return ntransfered;
--len;
++ntransfered;
++offset;
++fromOffset;
}
return ntransfered;
}
case pvString: {
String message("convert from int[] to StringArray not legal");
throw std::invalid_argument(message);
}
}
String message("Convert::convertFromIntArray should never get here");
throw std::logic_error(message);
}
int convertToIntArray(PVScalarArray * pv, int offset, int len,int32 to[], int toOffset)
{
ScalarType elemType = pv->getScalarArray()->getElementType();
int 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 = ByteArrayData();
while (len > 0) {
int num = 0;
num = pvdata->get(offset,len,&data);
if (num <= 0) break;
ByteArray dataArray = data.data;
int dataOffset = data.offset;
for(int 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 = ShortArrayData();
while (len > 0) {
int num = pvdata->get(offset, len, &data);
if (num == 0) break;
ShortArray dataArray = data.data;
int dataOffset = data.offset;
for (int 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 = IntArrayData();
while (len > 0) {
int num = pvdata->get(offset, len, &data);
if (num == 0) break;
IntArray dataArray = data.data;
int dataOffset = data.offset;
for (int 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 = LongArrayData();
while (len > 0) {
int num = pvdata->get(offset, len, &data);
if (num == 0)
break;
LongArray dataArray = data.data;
int dataOffset = data.offset;
for (int 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 = FloatArrayData();
while (len > 0) {
int num = pvdata->get(offset, len, &data);
if (num == 0) break;
FloatArray dataArray = data.data;
int dataOffset = data.offset;
for (int i = 0; i < num; i++)
to[i + toOffset] = dataArray[i + dataOffset];
len -= num;
offset += num;
toOffset += num;
ntransfered += num;
}
return ntransfered;
}
case pvDouble: {
PVDoubleArray *pvdata = static_cast<PVDoubleArray*>(pv);
DoubleArrayData data = DoubleArrayData();
while (len > 0) {
int num = pvdata->get(offset, len, &data);
if (num == 0)
break;
DoubleArray dataArray = data.data;
int dataOffset = data.offset;
for (int i = 0; i < num; i++)
to[i + toOffset] = dataArray[i + dataOffset];
len -= num;
offset += num;
toOffset += num;
ntransfered += num;
}
return ntransfered;
}
case pvString: {
String message("convert StringArray to int[]] not legal");
throw std::invalid_argument(message);
}
}
String message("Convert::convertToIntArray should never get here");
throw std::logic_error(message);
}
int convertFromLongArray(PVScalarArray *pv, int offset, int len,int64 from[], int fromOffset)
{
ScalarType elemType = pv->getScalarArray()->getElementType();
int ntransfered = 0;
switch (elemType) {
case pvBoolean: {
String message("convert from long[] 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] = 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] = 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] = 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);
while (len > 0) {
int n = pvdata->put(offset, len, from, fromOffset);
if (n == 0)
break;
len -= n;
offset += n;
fromOffset += n;
ntransfered += n;
}
return ntransfered;
}
case pvFloat: {
PVFloatArray *pvdata = static_cast<PVFloatArray*>(pv);
float data[1];
while (len > 0) {
data[0] = 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] = from[fromOffset];
if (pvdata->put(offset, 1, data, 0) == 0)
return ntransfered;
--len;
++ntransfered;
++offset;
++fromOffset;
}
return ntransfered;
}
case pvString: {
String message("convert from long[] to StringArray not legal");
throw std::invalid_argument(message);
}
}
String message("Convert::convertFromLongArray should never get here");
throw std::logic_error(message);
}
int convertToLongArray(PVScalarArray * pv, int offset, int len,int64 to[], int toOffset)
{
ScalarType elemType = pv->getScalarArray()->getElementType();
int ntransfered = 0;
switch (elemType) {
case pvBoolean: {
String message("convert BooleanArray to long[]] not legal");
throw std::invalid_argument(message);
}
case pvByte: {
PVByteArray *pvdata = static_cast<PVByteArray*>(pv);
ByteArrayData data = ByteArrayData();
while (len > 0) {
int num = 0;
num = pvdata->get(offset,len,&data);
if (num <= 0) break;
ByteArray dataArray = data.data;
int dataOffset = data.offset;
for(int 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 = ShortArrayData();
while (len > 0) {
int num = pvdata->get(offset, len, &data);
if (num == 0) break;
ShortArray dataArray = data.data;
int dataOffset = data.offset;
for (int 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 = IntArrayData();
while (len > 0) {
int num = pvdata->get(offset, len, &data);
if (num == 0) break;
IntArray dataArray = data.data;
int dataOffset = data.offset;
for (int 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 = LongArrayData();
while (len > 0) {
int num = pvdata->get(offset, len, &data);
if (num == 0)
break;
LongArray dataArray = data.data;
int dataOffset = data.offset;
for (int 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 = FloatArrayData();
while (len > 0) {
int num = pvdata->get(offset, len, &data);
if (num == 0) break;
FloatArray dataArray = data.data;
int dataOffset = data.offset;
for (int i = 0; i < num; i++)
to[i + toOffset] = dataArray[i + dataOffset];
len -= num;
offset += num;
toOffset += num;
ntransfered += num;
}
return ntransfered;
}
case pvDouble: {
PVDoubleArray *pvdata = static_cast<PVDoubleArray*>(pv);
DoubleArrayData data = DoubleArrayData();
while (len > 0) {
int num = pvdata->get(offset, len, &data);
if (num == 0)
break;
DoubleArray dataArray = data.data;
int dataOffset = data.offset;
for (int i = 0; i < num; i++)
to[i + toOffset] = dataArray[i + dataOffset];
len -= num;
offset += num;
toOffset += num;
ntransfered += num;
}
return ntransfered;
}
case pvString: {
String message("convert StringArray to long[]] not legal");
throw std::invalid_argument(message);
}
}
String message("Convert::convertToLongArray should never get here");
throw std::logic_error(message);
}
int convertFromFloatArray(PVScalarArray *pv, int offset, int len,float from[], int fromOffset)
{
ScalarType elemType = pv->getScalarArray()->getElementType();
int ntransfered = 0;
switch (elemType) {
case pvBoolean: {
String message("convert from float[] 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] = 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] = 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] = 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] = 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);
while (len > 0) {
int n = pvdata->put(offset, len, from, fromOffset);
if (n == 0)
break;
len -= n;
offset += n;
fromOffset += n;
ntransfered += n;
}
return ntransfered;
}
case pvDouble: {
PVDoubleArray *pvdata = static_cast<PVDoubleArray*>(pv);
double data[1];
while (len > 0) {
data[0] = from[fromOffset];
if (pvdata->put(offset, 1, data, 0) == 0)
return ntransfered;
--len;
++ntransfered;
++offset;
++fromOffset;
}
return ntransfered;
}
case pvString: {
String message("convert from float[] to StringArray not legal");
throw std::invalid_argument(message);
}
}
String message("Convert::convertFromFloatArray should never get here");
throw std::logic_error(message);
}
int convertToFloatArray(PVScalarArray * pv, int offset, int len,float to[], int toOffset)
{
ScalarType elemType = pv->getScalarArray()->getElementType();
int ntransfered = 0;
switch (elemType) {
case pvBoolean: {
String message("convert BooleanArray to float[]] not legal");
throw std::invalid_argument(message);
}
case pvByte: {
PVByteArray *pvdata = static_cast<PVByteArray*>(pv);
ByteArrayData data = ByteArrayData();
while (len > 0) {
int num = 0;
num = pvdata->get(offset,len,&data);
if (num <= 0) break;
ByteArray dataArray = data.data;
int dataOffset = data.offset;
for(int 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 = ShortArrayData();
while (len > 0) {
int num = pvdata->get(offset, len, &data);
if (num == 0) break;
ShortArray dataArray = data.data;
int dataOffset = data.offset;
for (int 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 = IntArrayData();
while (len > 0) {
int num = pvdata->get(offset, len, &data);
if (num == 0) break;
IntArray dataArray = data.data;
int dataOffset = data.offset;
for (int 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 = LongArrayData();
while (len > 0) {
int num = pvdata->get(offset, len, &data);
if (num == 0)
break;
LongArray dataArray = data.data;
int dataOffset = data.offset;
for (int 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 = FloatArrayData();
while (len > 0) {
int num = pvdata->get(offset, len, &data);
if (num == 0) break;
FloatArray dataArray = data.data;
int dataOffset = data.offset;
for (int i = 0; i < num; i++)
to[i + toOffset] = dataArray[i + dataOffset];
len -= num;
offset += num;
toOffset += num;
ntransfered += num;
}
return ntransfered;
}
case pvDouble: {
PVDoubleArray *pvdata = static_cast<PVDoubleArray*>(pv);
DoubleArrayData data = DoubleArrayData();
while (len > 0) {
int num = pvdata->get(offset, len, &data);
if (num == 0)
break;
DoubleArray dataArray = data.data;
int dataOffset = data.offset;
for (int i = 0; i < num; i++)
to[i + toOffset] = dataArray[i + dataOffset];
len -= num;
offset += num;
toOffset += num;
ntransfered += num;
}
return ntransfered;
}
case pvString: {
String message("convert StringArray to float[]] not legal");
throw std::invalid_argument(message);
}
}
String message("Convert::convertToFloatArray should never get here");
throw std::logic_error(message);
}
int convertFromDoubleArray(PVScalarArray *pv, int offset, int len,double from[], int fromOffset)
{
ScalarType elemType = pv->getScalarArray()->getElementType();
int ntransfered = 0;
switch (elemType) {
case pvBoolean: {
String message("convert from double[] 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] = 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] = 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] = 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] = 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] = 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);
while (len > 0) {
int n = pvdata->put(offset, len, from, fromOffset);
if (n == 0)
break;
len -= n;
offset += n;
fromOffset += n;
ntransfered += n;
}
return ntransfered;
}
case pvString: {
String message("convert from double[] to StringArray not legal");
throw std::invalid_argument(message);
}
}
String message("Convert::convertFromDoubleArray should never get here");
throw std::logic_error(message);
}
int convertToDoubleArray(PVScalarArray * pv, int offset, int len,double to[], int toOffset)
{
ScalarType elemType = pv->getScalarArray()->getElementType();
int ntransfered = 0;
switch (elemType) {
case pvBoolean: {
String message("convert BooleanArray to float[]] not legal");
throw std::invalid_argument(message);
}
case pvByte: {
PVByteArray *pvdata = static_cast<PVByteArray*>(pv);
ByteArrayData data = ByteArrayData();
while (len > 0) {
int num = 0;
num = pvdata->get(offset,len,&data);
if (num <= 0) break;
ByteArray dataArray = data.data;
int dataOffset = data.offset;
for(int 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 = ShortArrayData();
while (len > 0) {
int num = pvdata->get(offset, len, &data);
if (num == 0) break;
ShortArray dataArray = data.data;
int dataOffset = data.offset;
for (int 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 = IntArrayData();
while (len > 0) {
int num = pvdata->get(offset, len, &data);
if (num == 0) break;
IntArray dataArray = data.data;
int dataOffset = data.offset;
for (int 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 = LongArrayData();
while (len > 0) {
int num = pvdata->get(offset, len, &data);
if (num == 0)
break;
LongArray dataArray = data.data;
int dataOffset = data.offset;
for (int 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 = FloatArrayData();
while (len > 0) {
int num = pvdata->get(offset, len, &data);
if (num == 0) break;
FloatArray dataArray = data.data;
int dataOffset = data.offset;
for (int i = 0; i < num; i++)
to[i + toOffset] = dataArray[i + dataOffset];
len -= num;
offset += num;
toOffset += num;
ntransfered += num;
}
return ntransfered;
}
case pvDouble: {
PVDoubleArray *pvdata = static_cast<PVDoubleArray*>(pv);
DoubleArrayData data = DoubleArrayData();
while (len > 0) {
int num = pvdata->get(offset, len, &data);
if (num == 0)
break;
DoubleArray dataArray = data.data;
int dataOffset = data.offset;
for (int i = 0; i < num; i++)
to[i + toOffset] = dataArray[i + dataOffset];
len -= num;
offset += num;
toOffset += num;
ntransfered += num;
}
return ntransfered;
}
case pvString: {
String message("convert StringArray to double[]] not legal");
throw std::invalid_argument(message);
}
}
String message("Convert::convertToDoubleArray should never get here");
throw std::logic_error(message);
}
int convertFromStringArray(PVScalarArray *pv, int offset, int len,String from[], int fromOffset)
{
ScalarType elemType = pv->getScalarArray()->getElementType();
int ntransfered = 0;
switch (elemType) {
case pvBoolean: {
PVBooleanArray *pvdata = static_cast<PVBooleanArray*>(pv);
bool data[1];
while (len > 0) {
String fromString = from[fromOffset];
data[0] = (fromString.compare("true")==0) ? true : false;
if (pvdata->put(offset, 1, data, 0) == 0)
return ntransfered;
--len;
++ntransfered;
++offset;
++fromOffset;
}
return ntransfered;
}
case pvByte: {
PVByteArray *pvdata = static_cast<PVByteArray*>(pv);
int8 data[1];
while (len > 0) {
String fromString = from[fromOffset];
int ival;
sscanf(fromString.c_str(),"%d",&ival);
data[0] = ival;
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) {
String fromString = from[fromOffset];
int ival;
sscanf(fromString.c_str(),"%d",&ival);
data[0] = ival;
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) {
String fromString = from[fromOffset];
int ival;
sscanf(fromString.c_str(),"%d",&ival);
data[0] = ival;
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) {
String fromString = from[fromOffset];
int64 ival;
sscanf(fromString.c_str(),"%lld",&ival);
data[0] = ival;
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) {
String fromString = from[fromOffset];
float fval;
sscanf(fromString.c_str(),"%f",&fval);
data[0] = fval;
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) {
String fromString = from[fromOffset];
double fval;
sscanf(fromString.c_str(),"%lf",&fval);
data[0] = fval;
if (pvdata->put(offset, 1, data, 0) == 0)
return ntransfered;
--len;
++ntransfered;
++offset;
++fromOffset;
}
return ntransfered;
}
case pvString:
PVStringArray *pvdata = static_cast<PVStringArray*>(pv);
while (len > 0) {
int n = pvdata->put(offset, len, from, fromOffset);
if (n == 0)
break;
len -= n;
offset += n;
fromOffset += n;
ntransfered += n;
}
return ntransfered;
}
String message("Convert::convertFromStringArray should never get here");
throw std::logic_error(message);
}
int convertToStringArray(PVScalarArray * pv, int offset, int len,String to[], int toOffset)
{
ScalarType elementType = pv->getScalarArray()->getElementType();
int ncopy = pv->getLength();
if (ncopy > len) ncopy = len;
int num = ncopy;
switch (elementType) {
case pvBoolean: {
PVBooleanArray *pvdata = static_cast<PVBooleanArray*>(pv);
BooleanArrayData data = BooleanArrayData();
for (int i = 0; i < num; i++) {
if (pvdata->get(offset + i, 1, &data) == 1) {
BooleanArray dataArray = data.data;
bool value = dataArray[data.offset];
to[toOffset + i] = value ? trueString : falseString;
} else {
to[toOffset + i] = "bad pv";
}
}
}
break;
case pvByte: {
PVByteArray *pvdata = static_cast<PVByteArray*>(pv);
ByteArrayData data = ByteArrayData();
char cr[30];
for (int i = 0; i < num; i++) {
if (pvdata->get(offset + i, 1, &data) == 1) {
ByteArray dataArray = data.data;
int ival = dataArray[data.offset];
sprintf(cr,"%d",ival);
to[toOffset + i] = String(cr);
} else {
to[toOffset + i] = "bad pv";
}
}
}
break;
case pvShort: {
PVShortArray *pvdata = static_cast<PVShortArray*>(pv);
ShortArrayData data = ShortArrayData();
char cr[30];
for (int i = 0; i < num; i++) {
if (pvdata->get(offset + i, 1, &data) == 1) {
ShortArray dataArray = data.data;
int ival = dataArray[data.offset];
sprintf(cr,"%d",ival);
to[toOffset + i] = String(cr);
} else {
to[toOffset + i] = "bad pv";
}
}
}
break;
case pvInt: {
PVIntArray *pvdata = static_cast<PVIntArray*>(pv);
IntArrayData data = IntArrayData();
char cr[30];
for (int i = 0; i < num; i++) {
if (pvdata->get(offset + i, 1, &data) == 1) {
IntArray dataArray = data.data;
int ival = dataArray[data.offset];
sprintf(cr,"%d",ival);
to[toOffset + i] = String(cr);
} else {
to[toOffset + i] = "bad pv";
}
}
}
break;
case pvLong: {
PVLongArray *pvdata = static_cast<PVLongArray*>(pv);
LongArrayData data = LongArrayData();
char cr[30];
for (int i = 0; i < num; i++) {
if (pvdata->get(offset + i, 1, &data) == 1) {
LongArray dataArray = data.data;
int64 ival = dataArray[data.offset];
sprintf(cr,"%lld",ival);
to[toOffset + i] = String(cr);
} else {
to[toOffset + i] = "bad pv";
}
}
}
break;
case pvFloat: {
PVFloatArray *pvdata = static_cast<PVFloatArray*>(pv);
FloatArrayData data = FloatArrayData();
char cr[30];
for (int i = 0; i < num; i++) {
if (pvdata->get(offset + i, 1, &data) == 1) {
FloatArray dataArray = data.data;
float fval = dataArray[data.offset];
sprintf(cr,"%g",fval);
to[toOffset + i] = String(cr);
} else {
to[toOffset + i] = "bad pv";
}
}
}
break;
case pvDouble: {
PVDoubleArray *pvdata = static_cast<PVDoubleArray*>(pv);
DoubleArrayData data = DoubleArrayData();
char cr[30];
for (int i = 0; i < num; i++) {
if (pvdata->get(offset + i, 1, &data) == 1) {
DoubleArray dataArray = data.data;
double fval = dataArray[data.offset];
sprintf(cr,"%g",fval);
to[toOffset + i] = String(cr);
} else {
to[toOffset + i] = "bad pv";
}
}
}
break;
case pvString: {
PVStringArray *pvdata = static_cast<PVStringArray*>(pv);
while (num > 0) {
int numnow = 0;
StringArray dataArray = 0;
int dataOffset = 0;
StringArrayData stringArrayData = StringArrayData();
numnow = pvdata->get(offset, num, &stringArrayData);
dataArray = stringArrayData.data;
dataOffset = stringArrayData.offset;
if (numnow <= 0) {
for (int i = 0; i < num; i++)
to[toOffset + i] = "bad pv";
break;
}
for(int i=0; i<num; i++) to[toOffset+i] = dataArray[dataOffset+i];
num -= numnow;
offset += numnow;
toOffset += numnow;
}
}
break;
default:
String message("Convert::convertToStringArray should never get here");
throw std::logic_error(message);
}
return ncopy;
}
void convertToString(StringBuilder buffer,PVField * pv,int indentLevel)
{
Type type = pv->getField()->getType();
if(type==scalarArray) {
convertArray(buffer,static_cast<PVScalarArray *>(pv),indentLevel);
return;
}
if(type==structure) {
convertStructure(buffer,static_cast<PVStructure*>(pv),indentLevel);
return;
}
if(type==structureArray) {
convertStructureArray(
buffer,static_cast<PVStructureArray*>(pv),indentLevel);
return;
}
PVScalar *pvScalar = static_cast<PVScalar*>(pv);
ScalarConstPtr pscalar = pvScalar->getScalar();
ScalarType scalarType = pscalar->getScalarType();
ScalarTypeFunc::toString(buffer,scalarType);
*buffer += " ";
*buffer += pscalar->getFieldName();
*buffer += " ";
switch(scalarType) {
case pvBoolean: {
PVBoolean *data = static_cast<PVBoolean*>(pv);
bool value = data->get();
if(value) {
*buffer += "true";
} else {
*buffer += "false";
}
}
return;
case pvByte: {
PVByte *data = static_cast<PVByte*>(pv);
char xxx[30];
sprintf(xxx,"%d",(int)data->get());
*buffer += xxx;
}
return;
case pvShort: {
PVShort *data = static_cast<PVShort*>(pv);
char xxx[30];
sprintf(xxx,"%d",(int)data->get());
*buffer += xxx;
}
return;
case pvInt: {
PVInt *data = static_cast<PVInt*>(pv);
char xxx[30];
sprintf(xxx,"%d",(int)data->get());
*buffer += xxx;
}
return;
case pvLong: {
PVLong *data = static_cast<PVLong*>(pv);
char xxx[30];
sprintf(xxx,"%lld",(int64)data->get());
*buffer += xxx;
}
return;
case pvFloat: {
PVFloat *data = static_cast<PVFloat*>(pv);
char xxx[30];
sprintf(xxx,"%g",data->get());
*buffer += xxx;
}
return;
case pvDouble: {
PVDouble *data = static_cast<PVDouble*>(pv);
char xxx[30];
sprintf(xxx,"%lg",data->get());
*buffer += xxx;
}
return;
case pvString: {
PVString *data = static_cast<PVString*>(pv);
*buffer += data->get();
}
return;
default:
*buffer += "unknown ScalarType";
}
}
void convertStructure(StringBuilder buffer,PVStructure *data,int indentLevel)
{
String extendsName = data->getExtendsStructureName();
if(extendsName.length()<=0) {
*buffer += "structure ";
} else {
*buffer += extendsName;
*buffer += " ";
}
*buffer += data->getField()->getFieldName();
PVFieldPtrArray fieldsData = data->getPVFields();
if (fieldsData != 0) {
int length = data->getStructure()->getNumberFields();
for(int i=0; i<length; i++) {
convert->newLine(buffer, indentLevel+1);
PVField *fieldField = fieldsData[i];
fieldField->toString(buffer,indentLevel + 1);
}
}
}
void convertArray(StringBuilder buffer,PVScalarArray * pv,int indentLevel)
{
ScalarArrayConstPtr array = pv->getScalarArray();
ScalarType type = array->getElementType();
ScalarTypeFunc::toString(buffer,type);
*buffer += "[] ";
*buffer += array->getFieldName();
*buffer += " ";
switch(type) {
case pvBoolean: {
PVBooleanArray *pvdata = static_cast<PVBooleanArray*>(pv);
BooleanArrayData data = BooleanArrayData();
*buffer += "[";
for(int i=0; i < pvdata->getLength(); i++) {
if(i!=0) *buffer += ",";
int num = pvdata->get(i,1,&data);
if(num==1) {
BooleanArray value = data.data;
if(value[data.offset]) {
*buffer += "true";
} else {
*buffer += "false";
}
} else {
*buffer += "???? ";
}
}
*buffer += "]";
break;
}
case pvByte: {
PVByteArray *pvdata = static_cast<PVByteArray*>(pv);
ByteArrayData data = ByteArrayData();
*buffer += "[";
for(int i=0; i < pvdata->getLength(); i++) {
if(i!=0) *buffer += ",";
int num = pvdata->get(i,1,&data);
if(num==1) {
int val = data.data[data.offset];
char buf[16];
sprintf(buf,"%d",val);
*buffer += buf;
} else {
*buffer += "???? ";
}
}
*buffer += "]";
break;
}
case pvShort: {
PVShortArray *pvdata = static_cast<PVShortArray*>(pv);
ShortArrayData data = ShortArrayData();
*buffer += "[";
for(int i=0; i < pvdata->getLength(); i++) {
if(i!=0) *buffer += ',';
int num = pvdata->get(i,1,&data);
if(num==1) {
int val = data.data[data.offset];
char buf[16];
sprintf(buf,"%d",val);
*buffer += buf;
} else {
*buffer += "???? ";
}
}
*buffer += "]";
break;
}
case pvInt: {
PVIntArray *pvdata = static_cast<PVIntArray*>(pv);
IntArrayData data = IntArrayData();
*buffer += "[";
for(int i=0; i < pvdata->getLength(); i++) {
if(i!=0) *buffer += ',';
int num = pvdata->get(i,1,&data);
if(num==1) {
int val = data.data[data.offset];
char buf[16];
sprintf(buf,"%d",val);
*buffer += buf;
} else {
*buffer += "???? ";
}
}
*buffer += "]";
break;
}
case pvLong: {
PVLongArray *pvdata = static_cast<PVLongArray*>(pv);
LongArrayData data = LongArrayData();
*buffer += "[";
for(int i=0; i < pvdata->getLength(); i++) {
if(i!=0) *buffer += ',';
int num = pvdata->get(i,1,&data);
if(num==1) {
int64 val = data.data[data.offset];
char buf[16];
sprintf(buf,"%lld",val);
*buffer += buf;
} else {
*buffer += "???? ";
}
}
*buffer += "]";
break;
}
case pvFloat: {
PVFloatArray *pvdata = static_cast<PVFloatArray*>(pv);
FloatArrayData data = FloatArrayData();
*buffer += "[";
for(int i=0; i < pvdata->getLength(); i++) {
if(i!=0) *buffer += ',';
int num = pvdata->get(i,1,&data);
if(num==1) {
float val = data.data[data.offset];
char buf[16];
sprintf(buf,"%g",val);
*buffer += buf;
} else {
*buffer += "???? ";
}
}
*buffer += "]";
break;
}
case pvDouble: {
PVDoubleArray *pvdata = static_cast<PVDoubleArray*>(pv);
DoubleArrayData data = DoubleArrayData();
*buffer += "[";
for(int i=0; i < pvdata->getLength(); i++) {
if(i!=0) *buffer += ',';
int num = pvdata->get(i,1,&data);
if(num==1) {
double val = data.data[data.offset];
char buf[16];
sprintf(buf,"%lg",val);
*buffer += buf;
} else {
*buffer += "???? ";
}
}
*buffer += ("]");
break;
}
case pvString: {
PVStringArray *pvdata = static_cast<PVStringArray*>(pv);
StringArrayData data = StringArrayData();
*buffer += "[";
for(int i=0; i < pvdata->getLength(); i++) {
if(i!=0) *buffer += ",";
int num = pvdata->get(i,1,&data);
StringArray value = data.data;
if(num==1) {
if(value[data.offset].length()>0) {
*buffer += value[data.offset].c_str();
} else {
*buffer += "null";
}
} else {
*buffer += "null";
}
}
*buffer += "]";
break;
}
default:
*buffer += " array element is unknown ScalarType";
}
if(pv->isImmutable()) {
*buffer += " immutable ";
}
}
void convertStructureArray(StringBuilder buffer,
PVStructureArray * pvdata,int indentLevel)
{
*buffer += "structure[] ";
*buffer += pvdata->getField()->getFieldName();
*buffer += " ";
int length = pvdata->getLength();
if(length<=0) {
return;
}
StructureArrayData data = StructureArrayData();
pvdata->get(0, length, &data);
for (int i = 0; i < length; i++) {
convert->newLine(buffer, indentLevel + 1);
PVStructure *pvStructure = data.data[i];
if (pvStructure == 0) {
*buffer += "null";
} else {
pvStructure->toString(buffer,indentLevel+1);
}
}
}
int copyArrayDataReference(PVScalarArray *from,PVArray *to)
{
ScalarType scalarType = from->getScalarArray()->getElementType();
switch (scalarType) {
case pvBoolean: {
PVBooleanArray *pvfrom = (PVBooleanArray*) from;
PVBooleanArray *pvto = (PVBooleanArray*) to;
BooleanArrayData booleanArrayData = BooleanArrayData();
pvfrom->get(0, pvfrom->getLength(), &booleanArrayData);
BooleanArray booleanArray = booleanArrayData.data;
pvto->shareData(booleanArray,from->getCapacity(),from->getLength());
break;
}
case pvByte: {
PVByteArray *pvfrom = (PVByteArray*) from;
PVByteArray *pvto = (PVByteArray*) to;
ByteArrayData byteArrayData = ByteArrayData();
pvfrom->get(0, pvfrom->getLength(), &byteArrayData);
ByteArray byteArray = byteArrayData.data;
pvto->shareData(byteArray,from->getCapacity(),from->getLength());
break;
}
case pvShort: {
PVShortArray *pvfrom = (PVShortArray*) from;
PVShortArray *pvto = (PVShortArray*) to;
ShortArrayData shortArrayData = ShortArrayData();
pvfrom->get(0, pvfrom->getLength(), &shortArrayData);
ShortArray shortArray = shortArrayData.data;
pvto->shareData(shortArray,from->getCapacity(),from->getLength());
break;
}
case pvInt: {
PVIntArray *pvfrom = (PVIntArray*) from;
PVIntArray *pvto = (PVIntArray*) to;
IntArrayData intArrayData = IntArrayData();
pvfrom->get(0, pvfrom->getLength(), &intArrayData);
IntArray intArray = intArrayData.data;
pvto->shareData(intArray,from->getCapacity(),from->getLength());
break;
}
case pvLong: {
PVLongArray *pvfrom = (PVLongArray*) from;
PVLongArray *pvto = (PVLongArray*) to;
LongArrayData longArrayData = LongArrayData();
pvfrom->get(0, pvfrom->getLength(), &longArrayData);
LongArray longArray = longArrayData.data;
pvto->shareData(longArray,from->getCapacity(),from->getLength());
break;
}
case pvFloat: {
PVFloatArray *pvfrom = (PVFloatArray*) from;
PVFloatArray *pvto = (PVFloatArray*) to;
FloatArrayData longArrayData = FloatArrayData();
pvfrom->get(0, pvfrom->getLength(), &longArrayData);
FloatArray longArray = longArrayData.data;
pvto->shareData(longArray,from->getCapacity(),from->getLength());
break;
}
case pvDouble: {
PVDoubleArray *pvfrom = (PVDoubleArray*) from;
PVDoubleArray *pvto = (PVDoubleArray*) to;
DoubleArrayData doubleArrayData = DoubleArrayData();
pvfrom->get(0, pvfrom->getLength(), &doubleArrayData);
DoubleArray doubleArray = doubleArrayData.data;
pvto->shareData(doubleArray,from->getCapacity(),from->getLength());
break;
}
case pvString: {
PVStringArray *pvfrom = (PVStringArray*) from;
PVStringArray *pvto = (PVStringArray*) to;
StringArrayData stringArrayData = StringArrayData();
pvfrom->get(0, pvfrom->getLength(), &stringArrayData);
StringArray stringArray = stringArrayData.data;
pvto->shareData(stringArray,from->getCapacity(),from->getLength());
break;
}
}
to->setImmutable();
return from->getLength();
}
int copyNumericArray(PVScalarArray *from, int offset, PVScalarArray *to, int toOffset, int len)
{
ScalarType fromElementType = from->getScalarArray()->getElementType();
int 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) {
int num = 0;
ByteArrayData byteArrayData = ByteArrayData();
num = pvfrom->get(offset, len, &byteArrayData);
ByteArray data = byteArrayData.data;
int dataOffset = byteArrayData.offset;
if (num <= 0) break;
while (num > 0) {
int n = convert->fromByteArray(
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) {
int num = 0;
ShortArrayData shortArrayData = ShortArrayData();
num = pvfrom->get(offset, len, &shortArrayData);
ShortArray data = shortArrayData.data;
int dataOffset = shortArrayData.offset;
if (num <= 0) break;
while (num > 0) {
int n = convert->fromShortArray(
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) {
int num = 0;
IntArrayData shortArrayData = IntArrayData();
num = pvfrom->get(offset, len, &shortArrayData);
IntArray data = shortArrayData.data;
int dataOffset = shortArrayData.offset;
if (num <= 0) break;
while (num > 0) {
int n = convert->fromIntArray(
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) {
int num = 0;
LongArrayData longArrayData = LongArrayData();
num = pvfrom->get(offset, len, &longArrayData);
LongArray data = longArrayData.data;
int dataOffset = longArrayData.offset;
if (num <= 0) break;
while (num > 0) {
int n = convert->fromLongArray(
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) {
int num = 0;
FloatArrayData floatArrayData = FloatArrayData();
num = pvfrom->get(offset, len, &floatArrayData);
FloatArray data = floatArrayData.data;
int dataOffset = floatArrayData.offset;
if (num <= 0) break;
while (num > 0) {
int n = convert->fromFloatArray(
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) {
int num = 0;
DoubleArrayData doubleArrayData = DoubleArrayData();
num = pvfrom->get(offset, len, &doubleArrayData);
DoubleArray data = doubleArrayData.data;
int dataOffset = doubleArrayData.offset;
if (num <= 0) break;
while (num > 0) {
int n = convert->fromDoubleArray(
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;
}
class ConvertExt : public Convert {
public:
ConvertExt(): Convert(){};
};
Convert * getConvert() {
static Mutex mutex;
Lock xx(mutex);
if(convert==0){
convert = new ConvertExt();
pvDataCreate = getPVDataCreate();
}
return convert;
}
}}
Reference in New Issue View Git Blame Copy Permalink