size_t fromString(PVScalarArrayPtr const &pv, StringArray const & from, size_t fromStartIndex = 0) { int processed = 0; size_t fromValueCount = from.size(); // first get count if (fromStartIndex >= fromValueCount) throw std::runtime_error("not enough of values"); size_t count; istringstream iss(from[fromStartIndex]); iss >> count; // not fail and entire value is parsed (e.g. to detect 1.2 parsing to 1) if (iss.fail() || !iss.eof()) throw runtime_error("failed to parse element count value (uint) of field '" + pv->getFieldName() + "' from string value '" + from[fromStartIndex] + "'"); fromStartIndex++; processed++; if ((fromStartIndex+count) > fromValueCount) { throw runtime_error("not enough array values for field " + pv->getFieldName()); } PVStringArray::svector valueList(count); std::copy(from.begin() + fromStartIndex, from.begin() + fromStartIndex + count, valueList.begin()); processed += count; pv->putFrom<string>(freeze(valueList)); return processed; }
PVScalarArrayPtr PVDataCreate::createPVScalarArray( PVScalarArrayPtr const & arrayToClone) { PVScalarArrayPtr pvArray = createPVScalarArray( arrayToClone->getScalarArray()->getElementType()); pvArray->assign(*arrayToClone.get()); return pvArray; }
int64 NTNDArray::getValueSize() { int64 size = 0; PVScalarArrayPtr storedValue = getValue()->get<PVScalarArray>(); if (!storedValue.get()) { size = storedValue->getLength()*getValueTypeSize(); } return size; }
bool PVEnumerated::attach(PVFieldPtr const & pvField) { if(pvField->getField()->getType()!=structure) return false; PVStructurePtr pvStructure = static_pointer_cast<PVStructure>(pvField); pvIndex = pvStructure->getIntField("index"); if(pvIndex.get()==NULL) return false; PVScalarArrayPtr pvScalarArray = pvStructure->getScalarArrayField( "choices",pvString); if(pvScalarArray.get()==NULL) { pvIndex.reset(); return false; } pvChoices = static_pointer_cast<PVStringArray>(pvScalarArray); return true; }
size_t Convert::fromStringArray(PVScalarArrayPtr const &pv, size_t offset, size_t length, StringArray const & from, size_t fromOffset) { size_t alen = pv->getLength(); if(offset==0 && length>=alen) { // replace all existing elements assert(from.size()>=fromOffset+length); PVStringArray::svector data(length); std::copy(from.begin()+fromOffset, from.begin()+fromOffset+length, data.begin()); PVStringArray::const_svector temp(freeze(data)); pv->putFrom<string>(temp); return length; } else { // partial update. throw std::runtime_error("fromStringArray: partial update not implemented"); } }
static PVStructure::shared_pointer createPVStructure(CAChannel::shared_pointer const & channel, string const & properties) { PVStructure::shared_pointer pvStructure = getPVDataCreate()->createPVStructure(createStructure(channel, properties)); if (channel->getNativeType() == DBR_ENUM) { PVScalarArrayPtr pvScalarArray = pvStructure->getScalarArrayField("value.choices", pvString); // TODO avoid getting labels if DBR_GR_ENUM or DBR_CTRL_ENUM is used in subsequent get int result = ca_array_get_callback(DBR_GR_ENUM, 1, channel->getChannelID(), ca_get_labels_handler, pvScalarArray.get()); if (result == ECA_NORMAL) { ca_flush_io(); // NOTE: we do not wait here, since all subsequent request (over TCP) is serialized // and will guarantee that ca_get_labels_handler is called first } else { // TODO better error handling std::cerr << "failed to get labels for enum " << channel->getChannelName() << ": " << ca_message(result) << std::endl; } } return pvStructure; }
shared_vector<const double> PvaClientData::getDoubleArray() { if(PvaClient::getDebug()) cout << "PvaClientData::getDoubleArray\n"; PVScalarArrayPtr pvScalarArray; PVStructurePtr pvStructure = getPVStructure(); PVFieldPtr pvValue = pvStructure->getSubField("value"); if(pvValue) { Type type = pvValue->getField()->getType(); if(type==scalarArray) { pvScalarArray = static_pointer_cast<PVScalarArray>(pvValue); } } if(!pvScalarArray) { while(true) { const PVFieldPtrArray fieldPtrArray(pvStructure->getPVFields()); if(fieldPtrArray.size()!=1) { throw std::logic_error( "PvaClientData::getDoubleArray() pvRequest for multiple fields"); } PVFieldPtr pvField(fieldPtrArray[0]); Type type = pvField->getField()->getType(); if(type==scalarArray) { pvScalarArray = static_pointer_cast<PVScalarArray>(pvField); break; } if(pvField->getField()->getType()!=epics::pvData::structure) break; pvStructure = static_pointer_cast<PVStructure>(pvField); } } if(!pvScalarArray) { throw std::logic_error( "PvaClientData::getDoubleArray() did not find a scalarArray field"); } ScalarType scalarType = pvScalarArray->getScalarArray()->getElementType(); if(!ScalarTypeFunc::isNumeric(scalarType)) { throw std::logic_error( "PvaClientData::getDoubleArray() did not find a numeric scalarArray field"); } shared_vector<const double> retValue; pvScalarArray->getAs<const double>(retValue); return retValue; }
size_t Convert::fromString(PVScalarArrayPtr const &pv, string from) { if(from[0]=='[' && from[from.length()]==']') { size_t offset = from.rfind(']'); from = from.substr(1, offset); } std::vector<string> valueList(split(from)); size_t length = valueList.size(); size_t num = fromStringArray(pv,0,length,valueList,0); if(num<length) length = num; pv->setLength(length); return length; }
static void testScalarArrayCommon(string /*fieldName*/,ScalarType stype) { PVStructurePtr pvStructure = standardPVField->scalarArray( stype,alarmTimeStamp); PVScalarArrayPtr scalarArray = pvStructure->getSubField<PVScalarArray>("value"); testOk1(scalarArray.get()!=0); if(stype==pvBoolean) { StringArray values(3); values[0] = "true"; values[1] = "false"; values[2] = "true"; convert->fromStringArray(scalarArray, 0,3,values,0); } else { StringArray values(3); values[0] = "0"; values[1] = "1"; values[2] = "2"; convert->fromStringArray(scalarArray, 0,3,values,0); } PVFieldPtr pvField = pvStructure->getSubField<PVInt>("alarm.status"); testOk1(pvField.get()!=0); }
int64 NTNDArray::getValueTypeSize() { int64 typeSize = 0; PVScalarArrayPtr storedValue = getValue()->get<PVScalarArray>(); if (storedValue.get()) { switch (storedValue->getScalarArray()->getElementType()) { case pvBoolean: case pvByte: case pvUByte: typeSize = 1; break; case pvShort: case pvUShort: typeSize = 2; break; case pvInt: case pvUInt: case pvFloat: typeSize = 4; break; case pvLong: case pvULong: case pvDouble: typeSize = 8; break; default: break; } } return typeSize; }
static void testPVScalarArray( string const & valueNameMaster, string const & valueNameCopy, PVStructurePtr const & pvMaster, PVCopyPtr const & pvCopy) { PVStructurePtr pvStructureCopy; PVScalarArrayPtr pvValueMaster; PVScalarArrayPtr pvValueCopy; BitSetPtr bitSet; size_t offset; size_t n = 5; shared_vector<double> values(n); shared_vector<const double> cvalues; pvValueMaster = pvMaster->getSubField<PVScalarArray>(valueNameMaster); for(size_t i=0; i<n; i++) values[i] = i; const shared_vector<const double> xxx(freeze(values)); pvValueMaster->putFrom(xxx); StructureConstPtr structure = pvCopy->getStructure(); if(debug) { cout << "structure from copy" << endl << *structure << endl;} pvStructureCopy = pvCopy->createPVStructure(); pvValueCopy = pvStructureCopy->getSubField<PVScalarArray>(valueNameCopy); bitSet = BitSetPtr(new BitSet(pvStructureCopy->getNumberFields())); pvCopy->initCopy(pvStructureCopy, bitSet); if(debug) { cout << "after initCopy pvValueCopy " << *pvValueCopy << endl; } if(debug) { cout << endl; } values.resize(n); for(size_t i=0; i<n; i++) values[i] = i + .06; const shared_vector<const double> yyy(freeze(values)); pvValueMaster->putFrom(yyy); pvValueCopy->getAs(cvalues); testOk1(cvalues[0]==0.0); pvCopy->updateCopySetBitSet(pvStructureCopy,bitSet); pvValueCopy->getAs(cvalues); testOk1(cvalues[0]==0.06); if(debug) { cout << "after put(i+ .06) pvValueCopy " << *pvValueCopy << endl; } if(debug) { cout << " bitSet " << *bitSet; } if(debug) { cout << endl; } offset = pvCopy->getCopyOffset(pvValueMaster); if(debug) { cout << "getCopyOffset() " << offset; } if(debug) { cout << " pvValueCopy->getOffset() " << pvValueCopy->getFieldOffset(); } if(debug) { cout << " pvValueMaster->getOffset() " << pvValueMaster->getFieldOffset(); } if(debug) { cout << " bitSet " << *bitSet; } if(debug) { cout << endl; } bitSet->clear(); values.resize(n); for(size_t i=0; i<n; i++) values[i] = i + 1.0; const shared_vector<const double> zzz(freeze(values)); pvValueMaster->putFrom(zzz); if(debug) { cout << "before updateCopyFromBitSet"; } if(debug) { cout << " masterValue " << *pvValueMaster << endl; } if(debug) { cout << " copyValue " << *pvValueCopy << endl; } if(debug) { cout << " bitSet " << *bitSet; } if(debug) { cout << endl; } bitSet->set(0); pvValueCopy->getAs(cvalues); testOk1(cvalues[0]==0.06); pvCopy->updateCopyFromBitSet(pvStructureCopy,bitSet); pvValueCopy->getAs(cvalues); testOk1(cvalues[0]==1.0); if(debug) { cout << "after updateCopyFromBitSet"; } if(debug) { cout << " masterValue " << *pvValueMaster << endl; } if(debug) { cout << " copyValue " << *pvValueCopy << endl; } if(debug) { cout << " bitSet " << *bitSet; } if(debug) { cout << endl; } values.resize(n); for(size_t i=0; i<n; i++) values[i] = i + 2.0; const shared_vector<const double> ttt(freeze(values)); pvValueMaster->putFrom(ttt); bitSet->set(0); if(debug) { cout << "before updateMaster"; } if(debug) { cout << " masterValue " << *pvValueMaster << endl; } if(debug) { cout << " copyValue " << *pvValueCopy << endl; } if(debug) { cout << " bitSet " << *bitSet; } if(debug) { cout << endl; } pvValueMaster->getAs(cvalues); testOk1(cvalues[0]==2.0); pvCopy->updateMaster(pvStructureCopy,bitSet); pvValueMaster->getAs(cvalues); testOk1(cvalues[0]==1.0); if(debug) { cout << "before updateMaster"; } if(debug) { cout << " masterValue " << *pvValueMaster << endl; } if(debug) { cout << " copyValue " << *pvValueCopy << endl; } if(debug) { cout << " bitSet " << *bitSet; } if(debug) { cout << endl; } }
ChannelArrayLocalPtr ChannelArrayLocal::create( ChannelLocalPtr const &channelLocal, ChannelArrayRequester::shared_pointer const & channelArrayRequester, PVStructurePtr const & pvRequest, PVRecordPtr const &pvRecord) { PVFieldPtrArray const & pvFields = pvRequest->getPVFields(); if(pvFields.size()!=1) { Status status( Status::STATUSTYPE_ERROR,"invalid pvRequest"); ChannelArrayLocalPtr channelArray; ArrayConstPtr array; channelArrayRequester->channelArrayConnect(status,channelArray,array); return channelArray; } PVFieldPtr pvField = pvFields[0]; string fieldName(""); while(true) { string name = pvField->getFieldName(); if(fieldName.size()>0) fieldName += '.'; fieldName += name; PVStructurePtr pvs = static_pointer_cast<PVStructure>(pvField); PVFieldPtrArray const & pvfs = pvs->getPVFields(); if(pvfs.size()!=1) break; pvField = pvfs[0]; } size_t indfield = fieldName.find_first_of("field."); if(indfield==0) { fieldName = fieldName.substr(6); } pvField = pvRecord->getPVRecordStructure()->getPVStructure()->getSubField(fieldName); if(!pvField) { Status status( Status::STATUSTYPE_ERROR,fieldName +" not found"); ChannelArrayLocalPtr channelArray; ArrayConstPtr array; channelArrayRequester->channelArrayConnect( status,channelArray,array); return channelArray; } if(pvField->getField()->getType()!=scalarArray && pvField->getField()->getType()!=structureArray && pvField->getField()->getType()!=unionArray) { Status status( Status::STATUSTYPE_ERROR,fieldName +" not array"); ChannelArrayLocalPtr channelArray; ArrayConstPtr array; channelArrayRequester->channelArrayConnect( status,channelArray,array); return channelArray; } PVArrayPtr pvArray = static_pointer_cast<PVArray>(pvField); PVArrayPtr pvCopy; if(pvField->getField()->getType()==scalarArray) { PVScalarArrayPtr xxx = static_pointer_cast<PVScalarArray>(pvField); pvCopy = getPVDataCreate()->createPVScalarArray( xxx->getScalarArray()->getElementType()); } else if(pvField->getField()->getType()==structureArray) { PVStructureArrayPtr xxx = static_pointer_cast<PVStructureArray>(pvField); pvCopy = getPVDataCreate()->createPVStructureArray( xxx->getStructureArray()->getStructure()); } else { PVUnionArrayPtr xxx = static_pointer_cast<PVUnionArray>(pvField); pvCopy = getPVDataCreate()->createPVUnionArray( xxx->getUnionArray()->getUnion()); } ChannelArrayLocalPtr array(new ChannelArrayLocal( channelLocal, channelArrayRequester, pvArray, pvCopy, pvRecord)); if(pvRecord->getTraceLevel()>0) { cout << "ChannelArrayLocal::create"; cout << " recordName " << pvRecord->getRecordName() << endl; } channelArrayRequester->channelArrayConnect( Status::Ok, array, pvCopy->getArray()); return array; }
static void testPVScalarArray( ScalarType scalarType, string const & valueNameRecord, string const & valueNameCopy, PVRecordPtr const & pvRecord, PVCopyPtr const & pvCopy) { PVStructurePtr pvStructureRecord; PVStructurePtr pvStructureCopy; PVScalarArrayPtr pvValueRecord; PVScalarArrayPtr pvValueCopy; BitSetPtr bitSet; size_t offset; size_t n = 5; shared_vector<double> values(n); cout << endl; pvStructureRecord = pvRecord->getPVRecordStructure()->getPVStructure(); pvValueRecord = pvStructureRecord->getScalarArrayField(valueNameRecord,scalarType); for(size_t i=0; i<n; i++) values[i] = i; const shared_vector<const double> xxx(freeze(values)); pvValueRecord->putFrom(xxx); StructureConstPtr structure = pvCopy->getStructure(); cout << "structure from copy" << endl << *structure << endl; pvStructureCopy = pvCopy->createPVStructure(); pvValueCopy = pvStructureCopy->getScalarArrayField(valueNameCopy,scalarType); bitSet = BitSetPtr(new BitSet(pvStructureCopy->getNumberFields())); pvCopy->initCopy(pvStructureCopy, bitSet); cout << "after initCopy pvValueCopy " << *pvValueCopy << endl; cout << endl; values.resize(n); for(size_t i=0; i<n; i++) values[i] = i + .06; const shared_vector<const double> yyy(freeze(values)); pvValueRecord->putFrom(yyy); pvCopy->updateCopySetBitSet(pvStructureCopy,bitSet); cout << "after put(i+ .06) pvValueCopy " << *pvValueCopy << endl; cout << " bitSet " << *bitSet; cout << endl; offset = pvCopy->getCopyOffset(pvValueRecord); cout << "getCopyOffset() " << offset; cout << " pvValueCopy->getOffset() " << pvValueCopy->getFieldOffset(); cout << " pvValueRecord->getOffset() " << pvValueRecord->getFieldOffset(); cout << " bitSet " << *bitSet; cout << endl; bitSet->clear(); values.resize(n); for(size_t i=0; i<n; i++) values[i] = i + 1.0; const shared_vector<const double> zzz(freeze(values)); pvValueRecord->putFrom(zzz); cout << "before updateCopyFromBitSet"; cout << " recordValue " << *pvValueRecord << endl; cout << " copyValue " << *pvValueCopy << endl; cout << " bitSet " << *bitSet; cout << endl; bitSet->set(0); pvCopy->updateCopyFromBitSet(pvStructureCopy,bitSet); cout << "after updateCopyFromBitSet"; cout << " recordValue " << *pvValueRecord << endl; cout << " copyValue " << *pvValueCopy << endl; cout << " bitSet " << *bitSet; cout << endl; values.resize(n); for(size_t i=0; i<n; i++) values[i] = i + 2.0; const shared_vector<const double> ttt(freeze(values)); pvValueRecord->putFrom(ttt); bitSet->set(0); cout << "before updateMaster"; cout << " recordValue " << *pvValueRecord << endl; cout << " copyValue " << *pvValueCopy << endl; cout << " bitSet " << *bitSet; cout << endl; pvCopy->updateMaster(pvStructureCopy,bitSet); cout << "after updateMaster"; cout << " recordValue " << *pvValueRecord << endl; cout << " copyValue " << *pvValueRecord << endl; cout << " bitSet " << *bitSet; cout << endl; }
static void testConvertScalarArray(FILE *fd) { PVScalarArrayPtr pvBytePtr = pvDataCreate->createPVScalarArray(pvByte); PVScalarArrayPtr pvUBytePtr = pvDataCreate->createPVScalarArray(pvUByte); PVScalarArrayPtr pvShortPtr = pvDataCreate->createPVScalarArray(pvShort); PVScalarArrayPtr pvUShortPtr = pvDataCreate->createPVScalarArray(pvUShort); PVScalarArrayPtr pvIntPtr = pvDataCreate->createPVScalarArray(pvInt); PVScalarArrayPtr pvUIntPtr = pvDataCreate->createPVScalarArray(pvUInt); PVScalarArrayPtr pvLongPtr = pvDataCreate->createPVScalarArray(pvLong); PVScalarArrayPtr pvULongPtr = pvDataCreate->createPVScalarArray(pvULong); PVScalarArrayPtr pvFloatPtr = pvDataCreate->createPVScalarArray(pvFloat); PVScalarArrayPtr pvDoublePtr = pvDataCreate->createPVScalarArray(pvDouble); fprintf(fd,"testConvertScalarArray\n"); if(debug) fprintf(fd,"\nfromByte\n"); size_t length = 4; int8 barray[length]; int8 bval = 127; barray[0] = bval; for(size_t i=1; i<length; i++) barray[i] = barray[i-1] + 1; convert->fromByteArray(pvBytePtr,0,length,barray,0); builder.clear(); pvBytePtr->toString(&builder); if(debug) fprintf(fd,"byte %s\n",builder.c_str()); convert->fromByteArray(pvUBytePtr,0,length,barray,0); builder.clear(); pvUBytePtr->toString(&builder); if(debug) fprintf(fd,"ubyte %s\n",builder.c_str()); convert->fromByteArray(pvShortPtr,0,length,barray,0); builder.clear(); pvShortPtr->toString(&builder); if(debug) fprintf(fd,"short %s\n",builder.c_str()); convert->fromByteArray(pvUShortPtr,0,length,barray,0); builder.clear(); pvUShortPtr->toString(&builder); if(debug) fprintf(fd,"ushort %s\n",builder.c_str()); convert->fromByteArray(pvIntPtr,0,length,barray,0); builder.clear(); pvIntPtr->toString(&builder); if(debug) fprintf(fd,"int %s\n",builder.c_str()); convert->fromByteArray(pvUIntPtr,0,length,barray,0); builder.clear(); pvUIntPtr->toString(&builder); if(debug) fprintf(fd,"uint %s\n",builder.c_str()); convert->fromByteArray(pvLongPtr,0,length,barray,0); builder.clear(); pvLongPtr->toString(&builder); if(debug) fprintf(fd,"long %s\n",builder.c_str()); convert->fromByteArray(pvULongPtr,0,length,barray,0); builder.clear(); pvULongPtr->toString(&builder); if(debug) fprintf(fd,"ulong %s\n",builder.c_str()); convert->fromByteArray(pvFloatPtr,0,length,barray,0); builder.clear(); pvFloatPtr->toString(&builder); if(debug) fprintf(fd,"float %s\n",builder.c_str()); convert->fromByteArray(pvDoublePtr,0,length,barray,0); builder.clear(); pvDoublePtr->toString(&builder); if(debug) fprintf(fd,"double %s\n",builder.c_str()); convert->copyScalarArray(pvUBytePtr,0, pvFloatPtr,0,length); builder.clear(); pvFloatPtr->toString(&builder); if(debug) fprintf(fd,"float from unsigned %s\n",builder.c_str()); convert->copyScalarArray(pvUBytePtr,0, pvDoublePtr,0,length); builder.clear(); pvDoublePtr->toString(&builder); if(debug) fprintf(fd,"double from unsigned %s\n",builder.c_str()); fprintf(fd,"fromByte PASSED\n"); if(debug) fprintf(fd,"\nfromShort\n"); int16 sarray[length]; int16 sval = 0x7fff; sarray[0] = sval; for(size_t i=1; i<length; i++) sarray[i] = sarray[i-1] + 1; convert->fromShortArray(pvBytePtr,0,length,sarray,0); builder.clear(); pvBytePtr->toString(&builder); if(debug) fprintf(fd,"byte %s\n",builder.c_str()); convert->fromShortArray(pvUBytePtr,0,length,sarray,0); builder.clear(); pvUBytePtr->toString(&builder); if(debug) fprintf(fd,"ubyte %s\n",builder.c_str()); convert->fromShortArray(pvShortPtr,0,length,sarray,0); builder.clear(); pvShortPtr->toString(&builder); if(debug) fprintf(fd,"short %s\n",builder.c_str()); convert->fromShortArray(pvUShortPtr,0,length,sarray,0); builder.clear(); pvUShortPtr->toString(&builder); if(debug) fprintf(fd,"ushort %s\n",builder.c_str()); convert->fromShortArray(pvIntPtr,0,length,sarray,0); builder.clear(); pvIntPtr->toString(&builder); if(debug) fprintf(fd,"int %s\n",builder.c_str()); convert->fromShortArray(pvUIntPtr,0,length,sarray,0); builder.clear(); pvUIntPtr->toString(&builder); if(debug) fprintf(fd,"uint %s\n",builder.c_str()); convert->fromShortArray(pvLongPtr,0,length,sarray,0); builder.clear(); pvLongPtr->toString(&builder); if(debug) fprintf(fd,"long %s\n",builder.c_str()); convert->fromShortArray(pvULongPtr,0,length,sarray,0); builder.clear(); pvULongPtr->toString(&builder); if(debug) fprintf(fd,"ulong %s\n",builder.c_str()); convert->fromShortArray(pvFloatPtr,0,length,sarray,0); builder.clear(); pvFloatPtr->toString(&builder); if(debug) fprintf(fd,"float %s\n",builder.c_str()); convert->fromShortArray(pvDoublePtr,0,length,sarray,0); builder.clear(); pvDoublePtr->toString(&builder); if(debug) fprintf(fd,"double %s\n",builder.c_str()); convert->copyScalarArray(pvUShortPtr,0, pvFloatPtr,0,length); builder.clear(); pvFloatPtr->toString(&builder); if(debug) fprintf(fd,"float from unsigned %s\n",builder.c_str()); convert->copyScalarArray(pvUShortPtr,0, pvDoublePtr,0,length); builder.clear(); pvDoublePtr->toString(&builder); if(debug) fprintf(fd,"double from unsigned %s\n",builder.c_str()); fprintf(fd,"fromShort PASSED\n"); if(debug) fprintf(fd,"\nfromInt\n"); int32 iarray[length]; int32 ival = 0x7fffffff; iarray[0] = ival; for(size_t i=1; i<length; i++) iarray[i] = iarray[i-1] + 1; convert->fromIntArray(pvBytePtr,0,length,iarray,0); builder.clear(); pvBytePtr->toString(&builder); if(debug) fprintf(fd,"byte %s\n",builder.c_str()); convert->fromIntArray(pvUBytePtr,0,length,iarray,0); builder.clear(); pvUBytePtr->toString(&builder); if(debug) fprintf(fd,"ubyte %s\n",builder.c_str()); convert->fromIntArray(pvShortPtr,0,length,iarray,0); builder.clear(); pvShortPtr->toString(&builder); if(debug) fprintf(fd,"short %s\n",builder.c_str()); convert->fromIntArray(pvUShortPtr,0,length,iarray,0); builder.clear(); pvUShortPtr->toString(&builder); if(debug) fprintf(fd,"ushort %s\n",builder.c_str()); convert->fromIntArray(pvIntPtr,0,length,iarray,0); builder.clear(); pvIntPtr->toString(&builder); if(debug) fprintf(fd,"int %s\n",builder.c_str()); convert->fromIntArray(pvUIntPtr,0,length,iarray,0); builder.clear(); pvUIntPtr->toString(&builder); if(debug) fprintf(fd,"uint %s\n",builder.c_str()); convert->fromIntArray(pvLongPtr,0,length,iarray,0); builder.clear(); pvLongPtr->toString(&builder); if(debug) fprintf(fd,"long %s\n",builder.c_str()); convert->fromIntArray(pvULongPtr,0,length,iarray,0); builder.clear(); pvULongPtr->toString(&builder); if(debug) fprintf(fd,"ulong %s\n",builder.c_str()); convert->fromIntArray(pvFloatPtr,0,length,iarray,0); builder.clear(); pvFloatPtr->toString(&builder); if(debug) fprintf(fd,"float %s\n",builder.c_str()); convert->fromIntArray(pvDoublePtr,0,length,iarray,0); builder.clear(); pvDoublePtr->toString(&builder); if(debug) fprintf(fd,"double %s\n",builder.c_str()); convert->copyScalarArray(pvUIntPtr,0, pvFloatPtr,0,length); builder.clear(); pvFloatPtr->toString(&builder); if(debug) fprintf(fd,"float from unsigned %s\n",builder.c_str()); convert->copyScalarArray(pvUIntPtr,0, pvDoublePtr,0,length); builder.clear(); pvDoublePtr->toString(&builder); if(debug) fprintf(fd,"double from unsigned %s\n",builder.c_str()); fprintf(fd,"fromInt PASSED\n"); if(debug) fprintf(fd,"\nfromLong\n"); int64 larray[length]; int64 lval = 0x7fffffffffffffffLL; larray[0] = lval; for(size_t i=1; i<length; i++) larray[i] = larray[i-1] + 1; convert->fromLongArray(pvBytePtr,0,length,larray,0); builder.clear(); pvBytePtr->toString(&builder); if(debug) fprintf(fd,"byte %s\n",builder.c_str()); convert->fromLongArray(pvUBytePtr,0,length,larray,0); builder.clear(); pvUBytePtr->toString(&builder); if(debug) fprintf(fd,"ubyte %s\n",builder.c_str()); convert->fromLongArray(pvShortPtr,0,length,larray,0); builder.clear(); pvShortPtr->toString(&builder); if(debug) fprintf(fd,"short %s\n",builder.c_str()); convert->fromLongArray(pvUShortPtr,0,length,larray,0); builder.clear(); pvUShortPtr->toString(&builder); if(debug) fprintf(fd,"ushort %s\n",builder.c_str()); convert->fromLongArray(pvIntPtr,0,length,larray,0); builder.clear(); pvIntPtr->toString(&builder); if(debug) fprintf(fd,"int %s\n",builder.c_str()); convert->fromLongArray(pvUIntPtr,0,length,larray,0); builder.clear(); pvUIntPtr->toString(&builder); if(debug) fprintf(fd,"uint %s\n",builder.c_str()); convert->fromLongArray(pvLongPtr,0,length,larray,0); builder.clear(); pvLongPtr->toString(&builder); if(debug) fprintf(fd,"long %s\n",builder.c_str()); convert->fromLongArray(pvULongPtr,0,length,larray,0); builder.clear(); pvULongPtr->toString(&builder); if(debug) fprintf(fd,"ulong %s\n",builder.c_str()); convert->fromLongArray(pvFloatPtr,0,length,larray,0); builder.clear(); pvFloatPtr->toString(&builder); if(debug) fprintf(fd,"float %s\n",builder.c_str()); convert->fromLongArray(pvDoublePtr,0,length,larray,0); builder.clear(); pvDoublePtr->toString(&builder); if(debug) fprintf(fd,"double %s\n",builder.c_str()); convert->copyScalarArray(pvULongPtr,0, pvFloatPtr,0,length); builder.clear(); pvFloatPtr->toString(&builder); if(debug) fprintf(fd,"float from unsigned %s\n",builder.c_str()); convert->copyScalarArray(pvULongPtr,0, pvDoublePtr,0,length); builder.clear(); pvDoublePtr->toString(&builder); if(debug) fprintf(fd,"double from unsigned %s\n",builder.c_str()); fprintf(fd,"fromLong PASSED\n"); if(debug) fprintf(fd,"\nfromUByte\n"); uint8 ubarray[length]; uint8 ubval = 127; ubarray[0] = ubval; for(size_t i=1; i<length; i++) ubarray[i] = ubarray[i-1] + 1; convert->fromUByteArray(pvBytePtr,0,length,ubarray,0); builder.clear(); pvBytePtr->toString(&builder); if(debug) fprintf(fd,"byte %s\n",builder.c_str()); convert->fromUByteArray(pvUBytePtr,0,length,ubarray,0); builder.clear(); pvUBytePtr->toString(&builder); if(debug) fprintf(fd,"ubyte %s\n",builder.c_str()); convert->fromUByteArray(pvShortPtr,0,length,ubarray,0); builder.clear(); pvShortPtr->toString(&builder); if(debug) fprintf(fd,"short %s\n",builder.c_str()); convert->fromUByteArray(pvUShortPtr,0,length,ubarray,0); builder.clear(); pvUShortPtr->toString(&builder); if(debug) fprintf(fd,"ushort %s\n",builder.c_str()); convert->fromUByteArray(pvIntPtr,0,length,ubarray,0); builder.clear(); pvIntPtr->toString(&builder); if(debug) fprintf(fd,"int %s\n",builder.c_str()); convert->fromUByteArray(pvUIntPtr,0,length,ubarray,0); builder.clear(); pvUIntPtr->toString(&builder); if(debug) fprintf(fd,"uint %s\n",builder.c_str()); convert->fromUByteArray(pvLongPtr,0,length,ubarray,0); builder.clear(); pvLongPtr->toString(&builder); if(debug) fprintf(fd,"long %s\n",builder.c_str()); convert->fromUByteArray(pvULongPtr,0,length,ubarray,0); builder.clear(); pvULongPtr->toString(&builder); if(debug) fprintf(fd,"ulong %s\n",builder.c_str()); convert->fromUByteArray(pvFloatPtr,0,length,ubarray,0); builder.clear(); pvFloatPtr->toString(&builder); if(debug) fprintf(fd,"float %s\n",builder.c_str()); convert->fromUByteArray(pvDoublePtr,0,length,ubarray,0); builder.clear(); pvDoublePtr->toString(&builder); if(debug) fprintf(fd,"double %s\n",builder.c_str()); convert->copyScalarArray(pvUBytePtr,0, pvFloatPtr,0,length); builder.clear(); pvFloatPtr->toString(&builder); if(debug) fprintf(fd,"float from unsigned %s\n",builder.c_str()); convert->copyScalarArray(pvUBytePtr,0, pvDoublePtr,0,length); builder.clear(); pvDoublePtr->toString(&builder); if(debug) fprintf(fd,"double from unsigned %s\n",builder.c_str()); fprintf(fd,"fromUByte PASSED\n"); if(debug) fprintf(fd,"\nfromUShort\n"); uint16 usarray[length]; uint16 usval = 0x7fff; usarray[0] = usval; for(size_t i=1; i<length; i++) usarray[i] = usarray[i-1] + 1; convert->fromUShortArray(pvBytePtr,0,length,usarray,0); builder.clear(); pvBytePtr->toString(&builder); if(debug) fprintf(fd,"byte %s\n",builder.c_str()); convert->fromUShortArray(pvUBytePtr,0,length,usarray,0); builder.clear(); pvUBytePtr->toString(&builder); if(debug) fprintf(fd,"ubyte %s\n",builder.c_str()); convert->fromUShortArray(pvShortPtr,0,length,usarray,0); builder.clear(); pvShortPtr->toString(&builder); if(debug) fprintf(fd,"short %s\n",builder.c_str()); convert->fromUShortArray(pvUShortPtr,0,length,usarray,0); builder.clear(); pvUShortPtr->toString(&builder); if(debug) fprintf(fd,"ushort %s\n",builder.c_str()); convert->fromUShortArray(pvIntPtr,0,length,usarray,0); builder.clear(); pvIntPtr->toString(&builder); if(debug) fprintf(fd,"int %s\n",builder.c_str()); convert->fromUShortArray(pvUIntPtr,0,length,usarray,0); builder.clear(); pvUIntPtr->toString(&builder); if(debug) fprintf(fd,"uint %s\n",builder.c_str()); convert->fromUShortArray(pvLongPtr,0,length,usarray,0); builder.clear(); pvLongPtr->toString(&builder); if(debug) fprintf(fd,"long %s\n",builder.c_str()); convert->fromUShortArray(pvULongPtr,0,length,usarray,0); builder.clear(); pvULongPtr->toString(&builder); if(debug) fprintf(fd,"ulong %s\n",builder.c_str()); convert->fromUShortArray(pvFloatPtr,0,length,usarray,0); builder.clear(); pvFloatPtr->toString(&builder); if(debug) fprintf(fd,"float %s\n",builder.c_str()); convert->fromUShortArray(pvDoublePtr,0,length,usarray,0); builder.clear(); pvDoublePtr->toString(&builder); if(debug) fprintf(fd,"double %s\n",builder.c_str()); convert->copyScalarArray(pvUShortPtr,0, pvFloatPtr,0,length); builder.clear(); pvFloatPtr->toString(&builder); if(debug) fprintf(fd,"float from unsigned %s\n",builder.c_str()); convert->copyScalarArray(pvUShortPtr,0, pvDoublePtr,0,length); builder.clear(); pvDoublePtr->toString(&builder); if(debug) fprintf(fd,"double from unsigned %s\n",builder.c_str()); fprintf(fd,"fromUShort PASSED\n"); if(debug) fprintf(fd,"\nfromUInt\n"); uint32 uiarray[length]; uint32 uival = 0x7fffffff; uiarray[0] = uival; for(size_t i=1; i<length; i++) uiarray[i] = uiarray[i-1] + 1; convert->fromUIntArray(pvBytePtr,0,length,uiarray,0); builder.clear(); pvBytePtr->toString(&builder); if(debug) fprintf(fd,"byte %s\n",builder.c_str()); convert->fromUIntArray(pvUBytePtr,0,length,uiarray,0); builder.clear(); pvUBytePtr->toString(&builder); if(debug) fprintf(fd,"ubyte %s\n",builder.c_str()); convert->fromUIntArray(pvShortPtr,0,length,uiarray,0); builder.clear(); pvShortPtr->toString(&builder); if(debug) fprintf(fd,"short %s\n",builder.c_str()); convert->fromUIntArray(pvUShortPtr,0,length,uiarray,0); builder.clear(); pvUShortPtr->toString(&builder); if(debug) fprintf(fd,"ushort %s\n",builder.c_str()); convert->fromUIntArray(pvIntPtr,0,length,uiarray,0); builder.clear(); pvIntPtr->toString(&builder); if(debug) fprintf(fd,"int %s\n",builder.c_str()); convert->fromUIntArray(pvUIntPtr,0,length,uiarray,0); builder.clear(); pvUIntPtr->toString(&builder); if(debug) fprintf(fd,"uint %s\n",builder.c_str()); convert->fromUIntArray(pvLongPtr,0,length,uiarray,0); builder.clear(); pvLongPtr->toString(&builder); if(debug) fprintf(fd,"long %s\n",builder.c_str()); convert->fromUIntArray(pvULongPtr,0,length,uiarray,0); builder.clear(); pvULongPtr->toString(&builder); if(debug) fprintf(fd,"ulong %s\n",builder.c_str()); convert->fromUIntArray(pvFloatPtr,0,length,uiarray,0); builder.clear(); pvFloatPtr->toString(&builder); if(debug) fprintf(fd,"float %s\n",builder.c_str()); convert->fromUIntArray(pvDoublePtr,0,length,uiarray,0); builder.clear(); pvDoublePtr->toString(&builder); if(debug) fprintf(fd,"double %s\n",builder.c_str()); convert->copyScalarArray(pvUIntPtr,0, pvFloatPtr,0,length); builder.clear(); pvFloatPtr->toString(&builder); if(debug) fprintf(fd,"float from unsigned %s\n",builder.c_str()); convert->copyScalarArray(pvUIntPtr,0, pvDoublePtr,0,length); builder.clear(); pvDoublePtr->toString(&builder); if(debug) fprintf(fd,"double from unsigned %s\n",builder.c_str()); fprintf(fd,"fromUInt PASSED\n"); if(debug) fprintf(fd,"\nfromULong\n"); uint64 ularray[length]; uint64 ulval = 0x7fffffffffffffffLL; ularray[0] = ulval; for(size_t i=1; i<length; i++) ularray[i] = ularray[i-1] + 1; convert->fromULongArray(pvBytePtr,0,length,ularray,0); builder.clear(); pvBytePtr->toString(&builder); if(debug) fprintf(fd,"byte %s\n",builder.c_str()); convert->fromULongArray(pvUBytePtr,0,length,ularray,0); builder.clear(); pvUBytePtr->toString(&builder); if(debug) fprintf(fd,"ubyte %s\n",builder.c_str()); convert->fromULongArray(pvShortPtr,0,length,ularray,0); builder.clear(); pvShortPtr->toString(&builder); if(debug) fprintf(fd,"short %s\n",builder.c_str()); convert->fromULongArray(pvUShortPtr,0,length,ularray,0); builder.clear(); pvUShortPtr->toString(&builder); if(debug) fprintf(fd,"ushort %s\n",builder.c_str()); convert->fromULongArray(pvIntPtr,0,length,ularray,0); builder.clear(); pvIntPtr->toString(&builder); if(debug) fprintf(fd,"int %s\n",builder.c_str()); convert->fromULongArray(pvUIntPtr,0,length,ularray,0); builder.clear(); pvUIntPtr->toString(&builder); if(debug) fprintf(fd,"uint %s\n",builder.c_str()); convert->fromULongArray(pvLongPtr,0,length,ularray,0); builder.clear(); pvLongPtr->toString(&builder); if(debug) fprintf(fd,"long %s\n",builder.c_str()); convert->fromULongArray(pvULongPtr,0,length,ularray,0); builder.clear(); pvULongPtr->toString(&builder); if(debug) fprintf(fd,"ulong %s\n",builder.c_str()); convert->fromULongArray(pvFloatPtr,0,length,ularray,0); builder.clear(); pvFloatPtr->toString(&builder); if(debug) fprintf(fd,"float %s\n",builder.c_str()); convert->fromULongArray(pvDoublePtr,0,length,ularray,0); builder.clear(); pvDoublePtr->toString(&builder); if(debug) fprintf(fd,"double %s\n",builder.c_str()); convert->copyScalarArray(pvULongPtr,0, pvFloatPtr,0,length); builder.clear(); pvFloatPtr->toString(&builder); if(debug) fprintf(fd,"float from unsigned %s\n",builder.c_str()); convert->copyScalarArray(pvULongPtr,0, pvDoublePtr,0,length); builder.clear(); pvDoublePtr->toString(&builder); if(debug) fprintf(fd,"double from unsigned %s\n",builder.c_str()); fprintf(fd,"fromLong PASSED\n"); }