static void testPVScalarCommon(string /*fieldName*/,ScalarType stype)
{
PVScalarPtr pvScalar = pvDataCreate->createPVScalar(stype);
if(stype==pvBoolean) {
convert->fromString(pvScalar,string("true"));
} else {
convert->fromString(pvScalar,string("10"));
}
}
ConvertPtr Convert::getConvert()
{
static ConvertPtr convert;
static Mutex mutex;
Lock xx(mutex);
if(convert.get()==0) {
convert = ConvertPtr(new Convert());
}
return convert;
}
static void examplePVFieldPut(PvaClientPtr const &pva,string const & channelName,string const & providerName)
{
cout << "__examplePVFieldPut__ channelName " << channelName << " providerName " << providerName << endl;
PvaClientChannelPtr channel = pva->channel(channelName,providerName,2.0);
PvaClientPutPtr put = channel->put();
PvaClientPutDataPtr putData = put->getData();
PVScalarPtr pvScalar = static_pointer_cast<PVScalar>(putData->getValue());
convert->fromDouble(pvScalar,1.0); put->put();
cout << channel->get("field(value)")->getData()->showChanged(cout) << endl;
convert->fromDouble(pvScalar,2.0); put->put();
cout << channel->get("field(value)")->getData()->showChanged(cout) << endl;
}
string PvaClientData::getString()
{
if(PvaClient::getDebug()) cout << "PvaClientData::getString\n";
PVScalarPtr pvScalar;
PVStructurePtr pvStructure = getPVStructure();
PVFieldPtr pvValue = pvStructure->getSubField("value");
if(pvValue) {
Type type = pvValue->getField()->getType();
if(type==scalar) pvScalar = static_pointer_cast<PVScalar>(pvValue);
}
if(!pvScalar) {
while(true) {
const PVFieldPtrArray fieldPtrArray(pvStructure->getPVFields());
if(fieldPtrArray.size()!=1) {
throw std::logic_error(
"PvaClientData::getString() pvRequest for multiple fields");
}
PVFieldPtr pvField(fieldPtrArray[0]);
Type type = pvField->getField()->getType();
if(type==scalar) {
pvScalar = static_pointer_cast<PVScalar>(pvField);
break;
}
if(pvField->getField()->getType()!=epics::pvData::structure) break;
pvStructure = static_pointer_cast<PVStructure>(pvField);
}
}
if(!pvScalar) {
throw std::logic_error(
"PvaClientData::getString() did not find a scalar field");
}
return convert->toString(pvScalar);
}
static void examplePVFieldPut(PvaClientPtr const &pva)
{
cout << "example put\n";
PvaClientChannelPtr channel = pva->channel("exampleDouble");
PvaClientPutPtr put = channel->put();
PvaClientPutDataPtr putData = put->getData();
PVFieldPtr pvField = putData->getValue();
PVScalarPtr pvScalar = static_pointer_cast<PVScalar>(pvField);
try {
convert->fromDouble(pvScalar,1.0); put->put();
cout << channel->get("field()")->getData()->showChanged(cout) << endl;
convert->fromDouble(pvScalar,2.0); put->put();
cout << channel->get("field()")->getData()->showChanged(cout) << endl;
} catch (std::runtime_error e) {
cout << "exception " << e.what() << endl;
}
}
void PvaClientPutData::putStringArray(std::vector<std::string> const & value)
{
checkValue();
PVScalarArrayPtr pv = pvStructure->getSubField<PVScalarArray>("value");
if(!pv) {
throw std::runtime_error(messagePrefix + notScalarArray);
}
convert->fromStringArray(pv,0,value.size(),value,0);
}
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);
}
double PvaClientPutData::getDouble()
{
PVScalarPtr pvScalar = getScalarValue();
ScalarType scalarType = pvScalar->getScalar()->getScalarType();
if(scalarType==pvDouble) {
PVDoublePtr pvDouble = static_pointer_cast<PVDouble>(pvScalar);
return pvDouble->get();
}
if(!ScalarTypeFunc::isNumeric(scalarType)) {
throw std::runtime_error(messagePrefix + notCompatibleScalar);
}
return convert->toDouble(pvScalar);
}
void PvaClientMultiPutDouble::put(epics::pvData::shared_vector<double> const &data)
{
if(!isPutConnected) connect();
if(data.size()!=nchannel) {
throw std::runtime_error("data has wrong size");
}
shared_vector<epics::pvData::boolean> isConnected = pvaClientMultiChannel->getIsConnected();
for(size_t i=0; i<nchannel; ++i)
{
if(isConnected[i]) {
PVStructurePtr pvTop = pvaClientPut[i]->getData()->getPVStructure();
PVScalarPtr pvValue = pvTop->getSubField<PVScalar>("value");
convert->fromDouble(pvValue,data[i]);
pvaClientPut[i]->issuePut();
}
if(isConnected[i]) {
Status status = pvaClientPut[i]->waitPut();
if(status.isOK()) continue;
string message = string("channel ") + pvaClientChannelArray[i]->getChannelName()
+ " PvaChannelPut::waitPut " + status.getMessage();
throw std::runtime_error(message);
}
}
}
static void testPVScalarWithProperties(
string /*fieldName*/,ScalarType stype)
{
PVStructurePtr pvStructure;
bool hasValueAlarm = false;
bool hasBooleanAlarm = false;
bool hasDisplayControl = false;
switch(stype) {
case pvBoolean: {
pvStructure = standardPVField->scalar(
stype,alarmTimeStampValueAlarm);
hasBooleanAlarm = true;
PVBooleanPtr pvField = pvStructure->getSubField<PVBoolean>("value");
pvField->put(true);
break;
}
case pvByte: {
pvStructure = standardPVField->scalar(
stype,allProperties);
hasValueAlarm = true;
hasDisplayControl = true;
PVBytePtr pvField = pvStructure->getSubField<PVByte>("value");
pvField->put(127);
break;
}
case pvShort: {
pvStructure = standardPVField->scalar(
stype,allProperties);
hasValueAlarm = true;
hasDisplayControl = true;
PVShortPtr pvField = pvStructure->getSubField<PVShort>("value");
pvField->put(32767);
break;
}
case pvInt: {
pvStructure = standardPVField->scalar(
stype,allProperties);
hasValueAlarm = true;
hasDisplayControl = true;
PVIntPtr pvField = pvStructure->getSubField<PVInt>("value");
pvField->put((int32)0x80000000);
break;
}
case pvLong: {
pvStructure = standardPVField->scalar(
stype,allProperties);
hasValueAlarm = true;
hasDisplayControl = true;
PVLongPtr pvField = pvStructure->getSubField<PVLong>("value");
int64 value = 0x80000000;
value <<= 32;
value |= 0xffffffff;
pvField->put(value);
break;
}
case pvUByte: {
pvStructure = standardPVField->scalar(
stype,allProperties);
hasValueAlarm = true;
hasDisplayControl = true;
PVUBytePtr pvField = pvStructure->getSubField<PVUByte>("value");
pvField->put(255);
break;
}
case pvUShort: {
pvStructure = standardPVField->scalar(
stype,allProperties);
hasValueAlarm = true;
hasDisplayControl = true;
PVUShortPtr pvField = pvStructure->getSubField<PVUShort>("value");
pvField->put(65535);
break;
}
case pvUInt: {
pvStructure = standardPVField->scalar(
stype,allProperties);
hasValueAlarm = true;
hasDisplayControl = true;
PVUIntPtr pvField = pvStructure->getSubField<PVUInt>("value");
pvField->put((uint32)0x80000000);
break;
}
case pvULong: {
pvStructure = standardPVField->scalar(
stype,allProperties);
hasValueAlarm = true;
hasDisplayControl = true;
PVULongPtr pvField = pvStructure->getSubField<PVULong>("value");
int64 value = 0x80000000;
value <<= 32;
value |= 0xffffffff;
pvField->put(value);
break;
}
case pvFloat: {
pvStructure = standardPVField->scalar(
stype,allProperties);
hasValueAlarm = true;
hasDisplayControl = true;
PVFloatPtr pvField = pvStructure->getSubField<PVFloat>("value");
pvField->put(1.123e8);
break;
}
case pvDouble: {
pvStructure = standardPVField->scalar(
stype,allProperties);
hasValueAlarm = true;
hasDisplayControl = true;
PVDoublePtr pvField = pvStructure->getSubField<PVDouble>("value");
pvField->put(1.123e35);
break;
}
case pvString: {
pvStructure = standardPVField->scalar(
stype,alarmTimeStamp);
PVStringPtr pvField = pvStructure->getSubField<PVString>("value");
pvField->put(string("this is a string"));
break;
}
}
PVLongPtr seconds = pvStructure->getSubField<PVLong>(
string("timeStamp.secondsPastEpoch"));
testOk1(seconds.get()!=0);
seconds->put(123456789);
PVIntPtr nano = pvStructure->getSubField<PVInt>(string("timeStamp.nanoseconds"));
testOk1(nano.get()!=0);
nano->put(1000000);
PVIntPtr severity = pvStructure->getSubField<PVInt>(string("alarm.severity"));
testOk1(severity.get()!=0);
severity->put(2);
PVStringPtr message = pvStructure->getSubField<PVString>(string("alarm.message"));
testOk1(message.get()!=0);
message->put(string("messageForAlarm"));
if(hasDisplayControl) {
PVStringPtr desc = pvStructure->getSubField<PVString>(
string("display.description"));
testOk1(desc.get()!=0);
desc->put(string("this is a description"));
PVStringPtr format = pvStructure->getSubField<PVString>(
string("display.format"));
testOk1(format.get()!=0);
format->put(string("f10.2"));
PVStringPtr units = pvStructure->getSubField<PVString>(
string("display.units"));
testOk1(units.get()!=0);
units->put(string("SomeUnits"));
PVDoublePtr limit = pvStructure->getSubField<PVDouble>(
string("display.limitLow"));
testOk1(limit.get()!=0);
limit->put(0.0);
limit = pvStructure->getSubField<PVDouble>(
string("display.limitHigh"));
testOk1(limit.get()!=0);
limit->put(10.0);
limit = pvStructure->getSubField<PVDouble>(
string("control.limitLow"));
testOk1(limit.get()!=0);
limit->put(1.0);
limit = pvStructure->getSubField<PVDouble>(
string("control.limitHigh"));
testOk1(limit.get()!=0);
limit->put(9.0);
}
if(hasValueAlarm) {
PVBooleanPtr pvBoolean = pvStructure->getSubField<PVBoolean>("valueAlarm.active");
pvBoolean->put(true);
PVScalarPtr pvtemp = pvStructure->getSubField<PVScalar>("valueAlarm.lowAlarmLimit");
testOk1(pvtemp.get()!=0);
convert->fromDouble(pvtemp,1.0);
pvtemp = pvStructure->getSubField<PVScalar>("valueAlarm.highAlarmLimit");
testOk1(pvtemp.get()!=0);
convert->fromDouble(pvtemp,9.0);
severity = pvStructure->getSubField<PVInt>(
string("valueAlarm.lowAlarmSeverity"));
testOk1(severity.get()!=0);
severity->put(2);
severity = pvStructure->getSubField<PVInt>(
string("valueAlarm.highAlarmSeverity"));
testOk1(severity.get()!=0);
severity->put(2);
PVBooleanPtr active = pvStructure->getSubField<PVBoolean>(
string("valueAlarm.active"));
testOk1(active.get()!=0);
active->put(true);
}
if(hasBooleanAlarm) {
PVBooleanPtr pvBoolean = pvStructure->getSubField<PVBoolean>("valueAlarm.active");
pvBoolean->put(true);
severity = pvStructure->getSubField<PVInt>(
string("valueAlarm.falseSeverity"));
testOk1(severity.get()!=0);
severity->put(0);
severity = pvStructure->getSubField<PVInt>(
string("valueAlarm.trueSeverity"));
testOk1(severity.get()!=0);
severity->put(2);
severity = pvStructure->getSubField<PVInt>(
string("valueAlarm.changeStateSeverity"));
testOk1(severity.get()!=0);
severity->put(1);
}
}
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");
}
namespace epics { namespace pvaClient {
class PvaClientPostHandlerPvt: public PostHandler
{
PvaClientPutData * easyData;
size_t fieldNumber;
public:
PvaClientPostHandlerPvt(PvaClientPutData *easyData,size_t fieldNumber)
: easyData(easyData),fieldNumber(fieldNumber){}
void postPut() { easyData->postPut(fieldNumber);}
};
typedef std::tr1::shared_ptr<PVArray> PVArrayPtr;
static ConvertPtr convert = getConvert();
static string noValue("no value field");
static string notScalar("value is not a scalar");
static string notCompatibleScalar("value is not a compatible scalar");
static string notArray("value is not an array");
static string notScalarArray("value is not a scalarArray");
static string notDoubleArray("value is not a doubleArray");
static string notStringArray("value is not a stringArray");
PvaClientPutDataPtr PvaClientPutData::create(StructureConstPtr const & structure)
{
PvaClientPutDataPtr epv(new PvaClientPutData(structure));
return epv;
}
PvaClientPutData::PvaClientPutData(StructureConstPtr const & structure)
: structure(structure),
pvStructure(getPVDataCreate()->createPVStructure(structure)),
bitSet(BitSetPtr(new BitSet(pvStructure->getNumberFields())))
{
messagePrefix = "";
size_t nfields = pvStructure->getNumberFields();
postHandler.resize(nfields);
PVFieldPtr pvField;
for(size_t i =0; i<nfields; ++i)
{
postHandler[i] = PostHandlerPtr(new PvaClientPostHandlerPvt(this, i));
if(i==0) {
pvField = pvStructure;
} else {
pvField = pvStructure->getSubField(i);
}
pvField->setPostHandler(postHandler[i]);
}
pvValue = pvStructure->getSubField("value");
}
void PvaClientPutData::checkValue()
{
if(pvValue) return;
throw std::runtime_error(messagePrefix + noValue);
}
void PvaClientPutData::postPut(size_t fieldNumber)
{
bitSet->set(fieldNumber);
}
void PvaClientPutData::setMessagePrefix(std::string const & value)
{
messagePrefix = value + " ";
}
StructureConstPtr PvaClientPutData::getStructure()
{return structure;}
PVStructurePtr PvaClientPutData::getPVStructure()
{return pvStructure;}
BitSetPtr PvaClientPutData::getChangedBitSet()
{return bitSet;}
std::ostream & PvaClientPutData::showChanged(std::ostream & out)
{
size_t nextSet = bitSet->nextSetBit(0);
PVFieldPtr pvField;
while(nextSet!=string::npos) {
if(nextSet==0) {
pvField = pvStructure;
} else {
pvField = pvStructure->getSubField(nextSet);
}
string name = pvField->getFullName();
out << name << " = " << pvField << endl;
nextSet = bitSet->nextSetBit(nextSet+1);
}
return out;
}
bool PvaClientPutData::hasValue()
{
if(!pvValue) return false;
return true;
}
bool PvaClientPutData::isValueScalar()
{
if(!pvValue) return false;
if(pvValue->getField()->getType()==scalar) return true;
return false;
}
bool PvaClientPutData::isValueScalarArray()
{
if(!pvValue) return false;
if(pvValue->getField()->getType()==scalarArray) return true;
return false;
}
PVFieldPtr PvaClientPutData::getValue()
{
checkValue();
return pvValue;
}
PVScalarPtr PvaClientPutData::getScalarValue()
{
checkValue();
PVScalarPtr pv = pvStructure->getSubField<PVScalar>("value");
if(!pv) throw std::runtime_error(messagePrefix + notScalar);
return pv;
}
PVArrayPtr PvaClientPutData::getArrayValue()
{
checkValue();
PVArrayPtr pv = pvStructure->getSubField<PVArray>("value");
if(!pv) throw std::runtime_error(messagePrefix + notArray);
return pv;
}
PVScalarArrayPtr PvaClientPutData::getScalarArrayValue()
{
checkValue();
PVScalarArrayPtr pv = pvStructure->getSubField<PVScalarArray>("value");
if(!pv) throw std::runtime_error(messagePrefix + notScalarArray);
return pv;
}
double PvaClientPutData::getDouble()
{
PVScalarPtr pvScalar = getScalarValue();
ScalarType scalarType = pvScalar->getScalar()->getScalarType();
if(scalarType==pvDouble) {
PVDoublePtr pvDouble = static_pointer_cast<PVDouble>(pvScalar);
return pvDouble->get();
}
if(!ScalarTypeFunc::isNumeric(scalarType)) {
throw std::runtime_error(messagePrefix + notCompatibleScalar);
}
return convert->toDouble(pvScalar);
}
string PvaClientPutData::getString()
{
PVScalarPtr pvScalar = getScalarValue();
return convert->toString(pvScalar);
}
shared_vector<const double> PvaClientPutData::getDoubleArray()
{
checkValue();
PVDoubleArrayPtr pv = pvStructure->getSubField<PVDoubleArray>("value");
if(!pv) {
throw std::runtime_error(messagePrefix + notDoubleArray);
}
return pv->view();
}
shared_vector<const string> PvaClientPutData::getStringArray()
{
checkValue();
PVStringArrayPtr pv = pvStructure->getSubField<PVStringArray>("value");
if(!pv) {
throw std::runtime_error(messagePrefix + notStringArray);
}
return pv->view();
}
void PvaClientPutData::putDouble(double value)
{
PVScalarPtr pvScalar = getScalarValue();
ScalarType scalarType = pvScalar->getScalar()->getScalarType();
if(scalarType==pvDouble) {
PVDoublePtr pvDouble = static_pointer_cast<PVDouble>(pvScalar);
pvDouble->put(value);
return;
}
if(!ScalarTypeFunc::isNumeric(scalarType)) {
throw std::runtime_error(messagePrefix + notCompatibleScalar);
}
convert->fromDouble(pvScalar,value);
}
void PvaClientPutData::putString(std::string const & value)
{
PVScalarPtr pvScalar = getScalarValue();
convert->fromString(pvScalar,value);
}
void PvaClientPutData::putDoubleArray(shared_vector<const double> const & value)
{
checkValue();
PVDoubleArrayPtr pv = pvStructure->getSubField<PVDoubleArray>("value");
if(!pv) {
throw std::runtime_error(messagePrefix + notDoubleArray);
}
pv->replace(value);
}
void PvaClientPutData::putStringArray(shared_vector<const std::string> const & value)
{
checkValue();
PVStringArrayPtr pv = pvStructure->getSubField<PVStringArray>("value");
if(!pv) {
throw std::runtime_error(messagePrefix + notStringArray);
}
pv->replace(value);
}
void PvaClientPutData::putStringArray(std::vector<std::string> const & value)
{
checkValue();
PVScalarArrayPtr pv = pvStructure->getSubField<PVScalarArray>("value");
if(!pv) {
throw std::runtime_error(messagePrefix + notScalarArray);
}
convert->fromStringArray(pv,0,value.size(),value,0);
}
}}
void PvaClientPutData::putString(std::string const & value)
{
PVScalarPtr pvScalar = getScalarValue();
convert->fromString(pvScalar,value);
}
string PvaClientPutData::getString()
{
PVScalarPtr pvScalar = getScalarValue();
return convert->toString(pvScalar);
}
namespace epics { namespace pvaClient {
typedef std::tr1::shared_ptr<PVArray> PVArrayPtr;
static ConvertPtr convert = getConvert();
static string noStructure("no pvStructure ");
static string noValue("no value field");
static string noScalar("value is not a scalar");
static string noArray("value is not an array");
static string noScalarArray("value is not a scalarArray");
static string noAlarm("no alarm");
static string noTimeStamp("no timeStamp");
PvaClientDataPtr PvaClientData::create(StructureConstPtr const & structure)
{
if(PvaClient::getDebug()) cout << "PvaClientData::create\n";
PvaClientDataPtr epv(new PvaClientData(structure));
return epv;
}
PvaClientData::PvaClientData(StructureConstPtr const & structure)
: structure(structure)
{
}
void PvaClientData::checkValue()
{
if(PvaClient::getDebug()) cout << "PvaClientData::checkValue\n";
if(pvValue) return;
throw std::runtime_error(messagePrefix + noValue);
}
void PvaClientData::setMessagePrefix(std::string const & value)
{
messagePrefix = value + " ";
}
StructureConstPtr PvaClientData::getStructure()
{
return structure;
}
PVStructurePtr PvaClientData::getPVStructure()
{
if(pvStructure) return pvStructure;
throw std::runtime_error(messagePrefix + noStructure);
}
BitSetPtr PvaClientData::getChangedBitSet()
{
if(bitSet)return bitSet;
throw std::runtime_error(messagePrefix + noStructure);
}
std::ostream & PvaClientData::showChanged(std::ostream & out)
{
if(!bitSet) throw std::runtime_error(messagePrefix + noStructure);
size_t nextSet = bitSet->nextSetBit(0);
PVFieldPtr pvField;
while(nextSet!=string::npos) {
if(nextSet==0) {
pvField = pvStructure;
} else {
pvField = pvStructure->getSubField(nextSet);
}
string name = pvField->getFullName();
out << name << " = " << pvField << endl;
nextSet = bitSet->nextSetBit(nextSet+1);
}
return out;
}
void PvaClientData::setData(
PVStructurePtr const & pvStructureFrom,
BitSetPtr const & bitSetFrom)
{
if(PvaClient::getDebug()) cout << "PvaClientData::setData\n";
pvStructure = pvStructureFrom;
bitSet = bitSetFrom;
pvValue = pvStructure->getSubField("value");
}
bool PvaClientData::hasValue()
{
if(PvaClient::getDebug()) cout << "PvaClientData::hasValue\n";
if(!pvValue) return false;
return true;
}
bool PvaClientData::isValueScalar()
{
if(PvaClient::getDebug()) cout << "PvaClientData::isValueScalar\n";
if(!pvValue) return false;
if(pvValue->getField()->getType()==scalar) return true;
return false;
}
bool PvaClientData::isValueScalarArray()
{
if(PvaClient::getDebug()) cout << "PvaClientData::isValueScalarArray\n";
if(!pvValue) return false;
if(pvValue->getField()->getType()==scalarArray) return true;
return false;
}
PVFieldPtr PvaClientData::getValue()
{
if(PvaClient::getDebug()) cout << "PvaClientData::getValue\n";
checkValue();
return pvValue;
}
PVScalarPtr PvaClientData::getScalarValue()
{
if(PvaClient::getDebug()) cout << "PvaClientData::getScalarValue\n";
checkValue();
if(pvValue->getField()->getType()!=scalar) {
throw std::runtime_error(messagePrefix + noScalar);
}
return pvStructure->getSubField<PVScalar>("value");
}
PVArrayPtr PvaClientData::getArrayValue()
{
if(PvaClient::getDebug()) cout << "PvaClientData::getArrayValue\n";
checkValue();
Type type = pvValue->getField()->getType();
if(type!=scalarArray && type!=structureArray && type!=unionArray) {
throw std::runtime_error(messagePrefix + noArray);
}
return pvStructure->getSubField<PVArray>("value");
}
PVScalarArrayPtr PvaClientData::getScalarArrayValue()
{
if(PvaClient::getDebug()) cout << "PvaClientData::getScalarArrayValue\n";
checkValue();
Type type = pvValue->getField()->getType();
if(type!=scalarArray) {
throw std::runtime_error(messagePrefix + noScalarArray);
}
return pvStructure->getSubField<PVScalarArray>("value");
}
double PvaClientData::getDouble()
{
if(PvaClient::getDebug()) cout << "PvaClientData::getDouble\n";
PVScalarPtr pvScalar;
PVStructurePtr pvStructure = getPVStructure();
PVFieldPtr pvValue = pvStructure->getSubField("value");
if(pvValue) {
Type type = pvValue->getField()->getType();
if(type==scalar) pvScalar = static_pointer_cast<PVScalar>(pvValue);
}
if(!pvScalar) {
while(true) {
const PVFieldPtrArray fieldPtrArray(pvStructure->getPVFields());
if(fieldPtrArray.size()!=1) {
throw std::logic_error(
"PvaClientData::getDouble() pvRequest for multiple fields");
}
PVFieldPtr pvField(fieldPtrArray[0]);
Type type = pvField->getField()->getType();
if(type==scalar) {
pvScalar = static_pointer_cast<PVScalar>(pvField);
break;
}
if(pvField->getField()->getType()!=epics::pvData::structure) break;
pvStructure = static_pointer_cast<PVStructure>(pvField);
}
}
if(!pvScalar) {
throw std::logic_error(
"PvaClientData::getDouble() did not find a scalar field");
}
ScalarType scalarType = pvScalar->getScalar()->getScalarType();
if(scalarType==pvDouble) {
PVDoublePtr pvDouble = static_pointer_cast<PVDouble>(pvScalar);
return pvDouble->get();
}
if(!ScalarTypeFunc::isNumeric(scalarType)) {
throw std::logic_error(
"PvaClientData::getDouble() did not find a numeric scalar field");
}
return convert->toDouble(pvScalar);
}
string PvaClientData::getString()
{
if(PvaClient::getDebug()) cout << "PvaClientData::getString\n";
PVScalarPtr pvScalar;
PVStructurePtr pvStructure = getPVStructure();
PVFieldPtr pvValue = pvStructure->getSubField("value");
if(pvValue) {
Type type = pvValue->getField()->getType();
if(type==scalar) pvScalar = static_pointer_cast<PVScalar>(pvValue);
}
if(!pvScalar) {
while(true) {
const PVFieldPtrArray fieldPtrArray(pvStructure->getPVFields());
if(fieldPtrArray.size()!=1) {
throw std::logic_error(
"PvaClientData::getString() pvRequest for multiple fields");
}
PVFieldPtr pvField(fieldPtrArray[0]);
Type type = pvField->getField()->getType();
if(type==scalar) {
pvScalar = static_pointer_cast<PVScalar>(pvField);
break;
}
if(pvField->getField()->getType()!=epics::pvData::structure) break;
pvStructure = static_pointer_cast<PVStructure>(pvField);
}
}
if(!pvScalar) {
throw std::logic_error(
"PvaClientData::getString() did not find a scalar field");
}
return convert->toString(pvScalar);
}
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;
}
shared_vector<const string> PvaClientData::getStringArray()
{
if(PvaClient::getDebug()) cout << "PvaClientData::getStringArray\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::getStringArray() 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::getStringArray() did not find a scalarArray field");
}
shared_vector<const string> retValue;
pvScalarArray->getAs<const string>(retValue);
return retValue;
}
Alarm PvaClientData::getAlarm()
{
if(PvaClient::getDebug()) cout << "PvaClientData::getAlarm\n";
if(!pvStructure) throw new std::runtime_error(messagePrefix + noStructure);
PVStructurePtr pvs = pvStructure->getSubField<PVStructure>("alarm");
if(!pvs) throw std::runtime_error(messagePrefix + noAlarm);
pvAlarm.attach(pvs);
if(pvAlarm.isAttached()) {
Alarm alarm;
pvAlarm.get(alarm);
pvAlarm.detach();
return alarm;
}
throw std::runtime_error(messagePrefix + noAlarm);
}
TimeStamp PvaClientData::getTimeStamp()
{
if(PvaClient::getDebug()) cout << "PvaClientData::getTimeStamp\n";
if(!pvStructure) throw new std::runtime_error(messagePrefix + noStructure);
PVStructurePtr pvs = pvStructure->getSubField<PVStructure>("timeStamp");
if(!pvs) throw std::runtime_error(messagePrefix + noTimeStamp);
pvTimeStamp.attach(pvs);
if(pvTimeStamp.isAttached()) {
TimeStamp timeStamp;
pvTimeStamp.get(timeStamp);
pvTimeStamp.detach();
return timeStamp;
}
throw std::runtime_error(messagePrefix + noTimeStamp);
}
}}
static void testPVScalar(
string const & valueNameRecord,
string const & valueNameCopy,
PVRecordPtr const & pvRecord,
PVCopyPtr const & pvCopy)
{
PVStructurePtr pvStructureRecord;
PVStructurePtr pvStructureCopy;
PVFieldPtr pvField;
PVScalarPtr pvValueRecord;
PVScalarPtr pvValueCopy;
BitSetPtr bitSet;
size_t offset;
ConvertPtr convert = getConvert();
cout << endl;
pvStructureRecord = pvRecord->getPVRecordStructure()->getPVStructure();
pvField = pvStructureRecord->getSubField(valueNameRecord);
pvValueRecord = static_pointer_cast<PVScalar>(pvField);
convert->fromDouble(pvValueRecord,.04);
StructureConstPtr structure = pvCopy->getStructure();
cout << "structure from copy" << endl << *structure << endl;
pvStructureCopy = pvCopy->createPVStructure();
pvField = pvStructureCopy->getSubField(valueNameCopy);
pvValueCopy = static_pointer_cast<PVScalar>(pvField);
bitSet = BitSetPtr(new BitSet(pvStructureCopy->getNumberFields()));
pvCopy->initCopy(pvStructureCopy, bitSet);
cout << "after initCopy pvValueCopy " << convert->toDouble(pvValueCopy);
cout << endl;
convert->fromDouble(pvValueRecord,.06);
pvCopy->updateCopySetBitSet(pvStructureCopy,bitSet);
cout << "after put(.06) pvValueCopy " << convert->toDouble(pvValueCopy);
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();
convert->fromDouble(pvValueRecord,1.0);
cout << "before updateCopyFromBitSet";
cout << " recordValue " << convert->toDouble(pvValueRecord);
cout << " copyValue " << convert->toDouble(pvValueCopy);
cout << " bitSet " << *bitSet;
cout << endl;
bitSet->set(0);
pvCopy->updateCopyFromBitSet(pvStructureCopy,bitSet);
cout << "after updateCopyFromBitSet";
cout << " recordValue " << convert->toDouble(pvValueRecord);
cout << " copyValue " << convert->toDouble(pvValueCopy);
cout << " bitSet " << *bitSet;
cout << endl;
convert->fromDouble(pvValueCopy,2.0);
bitSet->set(0);
cout << "before updateMaster";
cout << " recordValue " << convert->toDouble(pvValueRecord);
cout << " copyValue " << convert->toDouble(pvValueCopy);
cout << " bitSet " << *bitSet;
cout << endl;
pvCopy->updateMaster(pvStructureCopy,bitSet);
cout << "after updateMaster";
cout << " recordValue " << convert->toDouble(pvValueRecord);
cout << " copyValue " << convert->toDouble(pvValueCopy);
cout << " bitSet " << *bitSet;
cout << endl;
}
namespace epics { namespace pvaClient {
static ConvertPtr convert = getConvert();
static FieldCreatePtr fieldCreate = getFieldCreate();
static PVDataCreatePtr pvDataCreate = getPVDataCreate();
static StandardFieldPtr standardField = getStandardField();
static CreateRequest::shared_pointer createRequest = CreateRequest::create();
PvaClientMultiPutDoublePtr PvaClientMultiPutDouble::create(
PvaClientMultiChannelPtr const &pvaMultiChannel,
PvaClientChannelArray const &pvaClientChannelArray)
{
PvaClientMultiPutDoublePtr pvaClientMultiPutDouble(
new PvaClientMultiPutDouble(pvaMultiChannel,pvaClientChannelArray));
return pvaClientMultiPutDouble;
}
PvaClientMultiPutDouble::PvaClientMultiPutDouble(
PvaClientMultiChannelPtr const &pvaClientMultiChannel,
PvaClientChannelArray const &pvaClientChannelArray)
: pvaClientMultiChannel(pvaClientMultiChannel),
pvaClientChannelArray(pvaClientChannelArray),
nchannel(pvaClientChannelArray.size()),
pvaClientPut(std::vector<PvaClientPutPtr>(nchannel,PvaClientPutPtr())),
isPutConnected(false),
isDestroyed(false)
{
}
PvaClientMultiPutDouble::~PvaClientMultiPutDouble()
{
destroy();
}
void PvaClientMultiPutDouble::destroy()
{
{
Lock xx(mutex);
if(isDestroyed) return;
isDestroyed = true;
}
pvaClientChannelArray.clear();
}
void PvaClientMultiPutDouble::connect()
{
shared_vector<epics::pvData::boolean> isConnected = pvaClientMultiChannel->getIsConnected();
for(size_t i=0; i<nchannel; ++i)
{
if(isConnected[i]) {
pvaClientPut[i] = pvaClientChannelArray[i]->createPut();
pvaClientPut[i]->issueConnect();
}
}
for(size_t i=0; i<nchannel; ++i)
{
if(isConnected[i]) {
Status status = pvaClientPut[i]->waitConnect();
if(status.isOK()) continue;
string message = string("channel ") + pvaClientChannelArray[i]->getChannelName()
+ " PvaChannelPut::waitConnect " + status.getMessage();
throw std::runtime_error(message);
}
}
isPutConnected = true;
}
void PvaClientMultiPutDouble::put(epics::pvData::shared_vector<double> const &data)
{
if(!isPutConnected) connect();
if(data.size()!=nchannel) {
throw std::runtime_error("data has wrong size");
}
shared_vector<epics::pvData::boolean> isConnected = pvaClientMultiChannel->getIsConnected();
for(size_t i=0; i<nchannel; ++i)
{
if(isConnected[i]) {
PVStructurePtr pvTop = pvaClientPut[i]->getData()->getPVStructure();
PVScalarPtr pvValue = pvTop->getSubField<PVScalar>("value");
convert->fromDouble(pvValue,data[i]);
pvaClientPut[i]->issuePut();
}
if(isConnected[i]) {
Status status = pvaClientPut[i]->waitPut();
if(status.isOK()) continue;
string message = string("channel ") + pvaClientChannelArray[i]->getChannelName()
+ " PvaChannelPut::waitPut " + status.getMessage();
throw std::runtime_error(message);
}
}
}
}}
static void testPVScalar(
string const & valueNameMaster,
string const & valueNameCopy,
PVStructurePtr const & pvMaster,
PVCopyPtr const & pvCopy)
{
PVStructurePtr pvStructureCopy;
PVScalarPtr pvValueMaster;
PVScalarPtr pvValueCopy;
BitSetPtr bitSet;
size_t offset;
ConvertPtr convert = getConvert();
pvValueMaster = pvMaster->getSubField<PVScalar>(valueNameMaster);
convert->fromDouble(pvValueMaster,.04);
StructureConstPtr structure = pvCopy->getStructure();
if(debug) { cout << "structure from copy" << endl << *structure << endl; }
pvStructureCopy = pvCopy->createPVStructure();
pvValueCopy = pvStructureCopy->getSubField<PVScalar>(valueNameCopy);
bitSet = BitSetPtr(new BitSet(pvStructureCopy->getNumberFields()));
pvCopy->initCopy(pvStructureCopy, bitSet);
if(debug) { cout << "after initCopy pvValueCopy " << convert->toDouble(pvValueCopy); }
if(debug) { cout << endl; }
convert->fromDouble(pvValueMaster,.06);
testOk1(convert->toDouble(pvValueCopy)==.04);
pvCopy->updateCopySetBitSet(pvStructureCopy,bitSet);
testOk1(convert->toDouble(pvValueCopy)==.06);
testOk1(bitSet->get(pvValueCopy->getFieldOffset()));
if(debug) { cout << "after put(.06) pvValueCopy " << convert->toDouble(pvValueCopy); }
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();
convert->fromDouble(pvValueMaster,1.0);
if(debug) { cout << "before updateCopyFromBitSet"; }
if(debug) { cout << " masterValue " << convert->toDouble(pvValueMaster); }
if(debug) { cout << " copyValue " << convert->toDouble(pvValueCopy); }
if(debug) { cout << " bitSet " << *bitSet; }
if(debug) { cout << endl; }
bitSet->set(0);
testOk1(convert->toDouble(pvValueCopy)==0.06);
pvCopy->updateCopyFromBitSet(pvStructureCopy,bitSet);
testOk1(convert->toDouble(pvValueCopy)==1.0);
if(debug) { cout << "after updateCopyFromBitSet"; }
if(debug) { cout << " masterValue " << convert->toDouble(pvValueMaster); }
if(debug) { cout << " copyValue " << convert->toDouble(pvValueCopy); }
if(debug) { cout << " bitSet " << *bitSet; }
if(debug) { cout << endl; }
convert->fromDouble(pvValueCopy,2.0);
bitSet->set(0);
if(debug) { cout << "before updateMaster"; }
if(debug) { cout << " masterValue " << convert->toDouble(pvValueMaster); }
if(debug) { cout << " copyValue " << convert->toDouble(pvValueCopy); }
if(debug) { cout << " bitSet " << *bitSet; }
if(debug) { cout << endl; }
testOk1(convert->toDouble(pvValueMaster)==1.0);
pvCopy->updateMaster(pvStructureCopy,bitSet);
testOk1(convert->toDouble(pvValueMaster)==2.0);
if(debug) { cout << "after updateMaster"; }
if(debug) { cout << " masterValue " << convert->toDouble(pvValueMaster); }
if(debug) { cout << " copyValue " << convert->toDouble(pvValueCopy); }
if(debug) { cout << " bitSet " << *bitSet; }
if(debug) { cout << endl; }
}
static void testConvertScalar(FILE *fd) {
PVScalarPtr pvBytePtr = pvDataCreate->createPVScalar(pvByte);
PVScalarPtr pvUBytePtr = pvDataCreate->createPVScalar(pvUByte);
PVScalarPtr pvShortPtr = pvDataCreate->createPVScalar(pvShort);
PVScalarPtr pvUShortPtr = pvDataCreate->createPVScalar(pvUShort);
PVScalarPtr pvIntPtr = pvDataCreate->createPVScalar(pvInt);
PVScalarPtr pvUIntPtr = pvDataCreate->createPVScalar(pvUInt);
PVScalarPtr pvLongPtr = pvDataCreate->createPVScalar(pvLong);
PVScalarPtr pvULongPtr = pvDataCreate->createPVScalar(pvULong);
PVScalarPtr pvFloatPtr = pvDataCreate->createPVScalar(pvFloat);
PVScalarPtr pvDoublePtr = pvDataCreate->createPVScalar(pvDouble);
fprintf(fd,"testConvertScalar\n");
if(debug) fprintf(fd,"\nfromByte\n");
int8 bval = 127;
for(int i=0; i<3; i++) {
convert->fromByte(pvBytePtr, bval);
builder.clear(); pvBytePtr->toString(&builder);
if(debug) fprintf(fd,"byte %s\n",builder.c_str());
convert->fromByte(pvUBytePtr, bval);
builder.clear(); pvUBytePtr->toString(&builder);
if(debug) fprintf(fd,"ubyte %s\n",builder.c_str());
convert->fromByte(pvShortPtr, bval);
builder.clear(); pvShortPtr->toString(&builder);
if(debug) fprintf(fd,"short %s\n",builder.c_str());
convert->fromByte(pvUShortPtr, bval);
builder.clear(); pvUShortPtr->toString(&builder);
if(debug) fprintf(fd,"ushort %s\n",builder.c_str());
convert->fromByte(pvIntPtr, bval);
builder.clear(); pvIntPtr->toString(&builder);
if(debug) fprintf(fd,"int %s\n",builder.c_str());
convert->fromByte(pvUIntPtr, bval);
builder.clear(); pvUIntPtr->toString(&builder);
if(debug) fprintf(fd,"uint %s\n",builder.c_str());
convert->fromByte(pvLongPtr, bval);
builder.clear(); pvLongPtr->toString(&builder);
if(debug) fprintf(fd,"long %s\n",builder.c_str());
convert->fromByte(pvULongPtr, bval);
builder.clear(); pvULongPtr->toString(&builder);
if(debug) fprintf(fd,"ulong %s\n",builder.c_str());
convert->fromByte(pvFloatPtr, bval);
builder.clear(); pvFloatPtr->toString(&builder);
if(debug) fprintf(fd,"float %s\n",builder.c_str());
convert->fromByte(pvDoublePtr, bval);
builder.clear(); pvDoublePtr->toString(&builder);
if(debug) fprintf(fd,"double %s\n",builder.c_str());
convert->copyScalar(pvUBytePtr, pvFloatPtr);
builder.clear(); pvFloatPtr->toString(&builder);
if(debug) fprintf(fd,"float from unsigned %s\n",builder.c_str());
convert->copyScalar(pvUBytePtr, pvDoublePtr);
builder.clear(); pvDoublePtr->toString(&builder);
if(debug) fprintf(fd,"double from unsigned %s\n",builder.c_str());
bval++;
}
fprintf(fd,"fromByte PASSED\n");
if(debug) fprintf(fd,"\nfromShort\n");
int16 sval = 0x7fff;
for(int i=0; i<3; i++) {
convert->fromShort(pvBytePtr, sval);
builder.clear(); pvBytePtr->toString(&builder);
if(debug) fprintf(fd,"byte %s\n",builder.c_str());
convert->fromShort(pvUBytePtr, sval);
builder.clear(); pvUBytePtr->toString(&builder);
if(debug) fprintf(fd,"ubyte %s\n",builder.c_str());
convert->fromShort(pvShortPtr, sval);
builder.clear(); pvShortPtr->toString(&builder);
if(debug) fprintf(fd,"short %s\n",builder.c_str());
convert->fromShort(pvUShortPtr, sval);
builder.clear(); pvUShortPtr->toString(&builder);
if(debug) fprintf(fd,"ushort %s\n",builder.c_str());
convert->fromShort(pvIntPtr, sval);
builder.clear(); pvIntPtr->toString(&builder);
if(debug) fprintf(fd,"int %s\n",builder.c_str());
convert->fromShort(pvUIntPtr, sval);
builder.clear(); pvUIntPtr->toString(&builder);
if(debug) fprintf(fd,"uint %s\n",builder.c_str());
convert->fromShort(pvLongPtr, sval);
builder.clear(); pvLongPtr->toString(&builder);
if(debug) fprintf(fd,"long %s\n",builder.c_str());
convert->fromShort(pvULongPtr, sval);
builder.clear(); pvULongPtr->toString(&builder);
if(debug) fprintf(fd,"ulong %s\n",builder.c_str());
convert->fromShort(pvFloatPtr, sval);
builder.clear(); pvFloatPtr->toString(&builder);
if(debug) fprintf(fd,"float %s\n",builder.c_str());
convert->fromShort(pvDoublePtr, sval);
builder.clear(); pvDoublePtr->toString(&builder);
if(debug) fprintf(fd,"double %s\n",builder.c_str());
convert->copyScalar(pvUShortPtr, pvFloatPtr);
builder.clear(); pvFloatPtr->toString(&builder);
if(debug) fprintf(fd,"float from unsigned %s\n",builder.c_str());
convert->copyScalar(pvUShortPtr, pvDoublePtr);
builder.clear(); pvDoublePtr->toString(&builder);
if(debug) fprintf(fd,"double from unsigned %s\n",builder.c_str());
sval++;
}
fprintf(fd,"fromShort PASSED\n");
if(debug) fprintf(fd,"\nfromInt\n");
int32 ival = 0x7fffffff;
for(int i=0; i<3; i++) {
convert->fromInt(pvBytePtr, ival);
builder.clear(); pvBytePtr->toString(&builder);
if(debug) fprintf(fd,"byte %s\n",builder.c_str());
convert->fromInt(pvUBytePtr, ival);
builder.clear(); pvUBytePtr->toString(&builder);
if(debug) fprintf(fd,"ubyte %s\n",builder.c_str());
convert->fromInt(pvShortPtr, ival);
builder.clear(); pvShortPtr->toString(&builder);
if(debug) fprintf(fd,"short %s\n",builder.c_str());
convert->fromInt(pvUShortPtr, ival);
builder.clear(); pvUShortPtr->toString(&builder);
if(debug) fprintf(fd,"ushort %s\n",builder.c_str());
convert->fromInt(pvIntPtr, ival);
builder.clear(); pvIntPtr->toString(&builder);
if(debug) fprintf(fd,"int %s\n",builder.c_str());
convert->fromInt(pvUIntPtr, ival);
builder.clear(); pvUIntPtr->toString(&builder);
if(debug) fprintf(fd,"uint %s\n",builder.c_str());
convert->fromInt(pvLongPtr, ival);
builder.clear(); pvLongPtr->toString(&builder);
if(debug) fprintf(fd,"long %s\n",builder.c_str());
convert->fromInt(pvULongPtr, ival);
builder.clear(); pvULongPtr->toString(&builder);
if(debug) fprintf(fd,"ulong %s\n",builder.c_str());
convert->fromInt(pvFloatPtr, ival);
builder.clear(); pvFloatPtr->toString(&builder);
if(debug) fprintf(fd,"float %s\n",builder.c_str());
convert->fromInt(pvDoublePtr, ival);
builder.clear(); pvDoublePtr->toString(&builder);
if(debug) fprintf(fd,"double %s\n",builder.c_str());
convert->copyScalar(pvUIntPtr, pvFloatPtr);
builder.clear(); pvFloatPtr->toString(&builder);
if(debug) fprintf(fd,"float from unsigned %s\n",builder.c_str());
convert->copyScalar(pvUIntPtr, pvDoublePtr);
builder.clear(); pvDoublePtr->toString(&builder);
if(debug) fprintf(fd,"double from unsigned %s\n",builder.c_str());
ival++;
}
fprintf(fd,"fromInt PASSED\n");
if(debug) fprintf(fd,"\nfromLong\n");
int64 lval = 0x7fffffffffffffffLL;
for(int i=0; i<3; i++) {
convert->fromLong(pvBytePtr, lval);
builder.clear(); pvBytePtr->toString(&builder);
if(debug) fprintf(fd,"byte %s\n",builder.c_str());
convert->fromLong(pvUBytePtr, lval);
builder.clear(); pvUBytePtr->toString(&builder);
if(debug) fprintf(fd,"ubyte %s\n",builder.c_str());
convert->fromLong(pvShortPtr, lval);
builder.clear(); pvShortPtr->toString(&builder);
if(debug) fprintf(fd,"short %s\n",builder.c_str());
convert->fromLong(pvUShortPtr, lval);
builder.clear(); pvUShortPtr->toString(&builder);
if(debug) fprintf(fd,"ushort %s\n",builder.c_str());
convert->fromLong(pvIntPtr, lval);
builder.clear(); pvIntPtr->toString(&builder);
if(debug) fprintf(fd,"int %s\n",builder.c_str());
convert->fromLong(pvUIntPtr, lval);
builder.clear(); pvUIntPtr->toString(&builder);
if(debug) fprintf(fd,"uint %s\n",builder.c_str());
convert->fromLong(pvLongPtr, lval);
builder.clear(); pvLongPtr->toString(&builder);
if(debug) fprintf(fd,"long %s\n",builder.c_str());
convert->fromLong(pvULongPtr, lval);
builder.clear(); pvULongPtr->toString(&builder);
if(debug) fprintf(fd,"ulong %s\n",builder.c_str());
convert->fromLong(pvFloatPtr, lval);
builder.clear(); pvFloatPtr->toString(&builder);
if(debug) fprintf(fd,"float %s\n",builder.c_str());
convert->fromLong(pvDoublePtr, lval);
builder.clear(); pvDoublePtr->toString(&builder);
if(debug) fprintf(fd,"double %s\n",builder.c_str());
convert->copyScalar(pvULongPtr, pvFloatPtr);
builder.clear(); pvFloatPtr->toString(&builder);
if(debug) fprintf(fd,"float from unsigned %s\n",builder.c_str());
convert->copyScalar(pvULongPtr, pvDoublePtr);
builder.clear(); pvDoublePtr->toString(&builder);
if(debug) fprintf(fd,"double from unsigned %s\n",builder.c_str());
lval++;
}
fprintf(fd,"fromLong PASSED\n");
if(debug) fprintf(fd,"\nfromUByte\n");
uint8 ubval = 127;
for(int i=0; i<3; i++) {
convert->fromUByte(pvBytePtr, ubval);
builder.clear(); pvBytePtr->toString(&builder);
if(debug) fprintf(fd,"byte %s\n",builder.c_str());
convert->fromUByte(pvUBytePtr, ubval);
builder.clear(); pvUBytePtr->toString(&builder);
if(debug) fprintf(fd,"ubyte %s\n",builder.c_str());
convert->fromUByte(pvShortPtr, ubval);
builder.clear(); pvShortPtr->toString(&builder);
if(debug) fprintf(fd,"short %s\n",builder.c_str());
convert->fromUByte(pvUShortPtr, ubval);
builder.clear(); pvUShortPtr->toString(&builder);
if(debug) fprintf(fd,"ushort %s\n",builder.c_str());
convert->fromUByte(pvIntPtr, ubval);
builder.clear(); pvIntPtr->toString(&builder);
if(debug) fprintf(fd,"int %s\n",builder.c_str());
convert->fromUByte(pvUIntPtr, ubval);
builder.clear(); pvUIntPtr->toString(&builder);
if(debug) fprintf(fd,"uint %s\n",builder.c_str());
convert->fromUByte(pvLongPtr, ubval);
builder.clear(); pvLongPtr->toString(&builder);
if(debug) fprintf(fd,"long %s\n",builder.c_str());
convert->fromUByte(pvULongPtr, ubval);
builder.clear(); pvULongPtr->toString(&builder);
if(debug) fprintf(fd,"ulong %s\n",builder.c_str());
convert->fromUByte(pvFloatPtr, ubval);
builder.clear(); pvFloatPtr->toString(&builder);
if(debug) fprintf(fd,"float %s\n",builder.c_str());
convert->fromUByte(pvDoublePtr, ubval);
builder.clear(); pvDoublePtr->toString(&builder);
if(debug) fprintf(fd,"double %s\n",builder.c_str());
convert->copyScalar(pvUBytePtr, pvFloatPtr);
builder.clear(); pvFloatPtr->toString(&builder);
if(debug) fprintf(fd,"float from unsigned %s\n",builder.c_str());
convert->copyScalar(pvUBytePtr, pvDoublePtr);
builder.clear(); pvDoublePtr->toString(&builder);
if(debug) fprintf(fd,"double from unsigned %s\n",builder.c_str());
ubval++;
}
fprintf(fd,"fromUByte PASSED\n");
if(debug) fprintf(fd,"\nfromUShort\n");
uint16 usval = 0x7fff;
for(int i=0; i<3; i++) {
convert->fromUShort(pvBytePtr, usval);
builder.clear(); pvBytePtr->toString(&builder);
if(debug) fprintf(fd,"byte %s\n",builder.c_str());
convert->fromUShort(pvUBytePtr, usval);
builder.clear(); pvUBytePtr->toString(&builder);
if(debug) fprintf(fd,"ubyte %s\n",builder.c_str());
convert->fromUShort(pvShortPtr, usval);
builder.clear(); pvShortPtr->toString(&builder);
if(debug) fprintf(fd,"short %s\n",builder.c_str());
convert->fromUShort(pvUShortPtr, usval);
builder.clear(); pvUShortPtr->toString(&builder);
if(debug) fprintf(fd,"ushort %s\n",builder.c_str());
convert->fromUShort(pvIntPtr, usval);
builder.clear(); pvIntPtr->toString(&builder);
if(debug) fprintf(fd,"int %s\n",builder.c_str());
convert->fromUShort(pvUIntPtr, usval);
builder.clear(); pvUIntPtr->toString(&builder);
if(debug) fprintf(fd,"uint %s\n",builder.c_str());
convert->fromUShort(pvLongPtr, usval);
builder.clear(); pvLongPtr->toString(&builder);
if(debug) fprintf(fd,"long %s\n",builder.c_str());
convert->fromUShort(pvULongPtr, usval);
builder.clear(); pvULongPtr->toString(&builder);
if(debug) fprintf(fd,"ulong %s\n",builder.c_str());
convert->fromUShort(pvFloatPtr, usval);
builder.clear(); pvFloatPtr->toString(&builder);
if(debug) fprintf(fd,"float %s\n",builder.c_str());
convert->fromUShort(pvDoublePtr, usval);
builder.clear(); pvDoublePtr->toString(&builder);
if(debug) fprintf(fd,"double %s\n",builder.c_str());
convert->copyScalar(pvUShortPtr, pvFloatPtr);
builder.clear(); pvFloatPtr->toString(&builder);
if(debug) fprintf(fd,"float from unsigned %s\n",builder.c_str());
convert->copyScalar(pvUShortPtr, pvDoublePtr);
builder.clear(); pvDoublePtr->toString(&builder);
if(debug) fprintf(fd,"double from unsigned %s\n",builder.c_str());
usval++;
}
fprintf(fd,"fromUShort PASSED\n");
if(debug) fprintf(fd,"\nfromUInt\n");
uint32 uival = 0x7fffffff;
for(int i=0; i<3; i++) {
convert->fromUInt(pvBytePtr, uival);
builder.clear(); pvBytePtr->toString(&builder);
if(debug) fprintf(fd,"byte %s\n",builder.c_str());
convert->fromUInt(pvUBytePtr, uival);
builder.clear(); pvUBytePtr->toString(&builder);
if(debug) fprintf(fd,"ubyte %s\n",builder.c_str());
convert->fromUInt(pvShortPtr, uival);
builder.clear(); pvShortPtr->toString(&builder);
if(debug) fprintf(fd,"short %s\n",builder.c_str());
convert->fromUInt(pvUShortPtr, uival);
builder.clear(); pvUShortPtr->toString(&builder);
if(debug) fprintf(fd,"ushort %s\n",builder.c_str());
convert->fromUInt(pvIntPtr, uival);
builder.clear(); pvIntPtr->toString(&builder);
if(debug) fprintf(fd,"int %s\n",builder.c_str());
convert->fromUInt(pvUIntPtr, uival);
builder.clear(); pvUIntPtr->toString(&builder);
if(debug) fprintf(fd,"uint %s\n",builder.c_str());
convert->fromUInt(pvLongPtr, uival);
builder.clear(); pvLongPtr->toString(&builder);
if(debug) fprintf(fd,"long %s\n",builder.c_str());
convert->fromUInt(pvULongPtr, uival);
builder.clear(); pvULongPtr->toString(&builder);
if(debug) fprintf(fd,"ulong %s\n",builder.c_str());
convert->fromUInt(pvFloatPtr, uival);
builder.clear(); pvFloatPtr->toString(&builder);
if(debug) fprintf(fd,"float %s\n",builder.c_str());
convert->fromUInt(pvDoublePtr, uival);
builder.clear(); pvDoublePtr->toString(&builder);
if(debug) fprintf(fd,"double %s\n",builder.c_str());
convert->copyScalar(pvUIntPtr, pvFloatPtr);
builder.clear(); pvFloatPtr->toString(&builder);
if(debug) fprintf(fd,"float from unsigned %s\n",builder.c_str());
convert->copyScalar(pvUIntPtr, pvDoublePtr);
builder.clear(); pvDoublePtr->toString(&builder);
if(debug) fprintf(fd,"double from unsigned %s\n",builder.c_str());
uival++;
}
fprintf(fd,"fromUInt PASSED\n");
if(debug) fprintf(fd,"\nfromULong\n");
uint64 ulval = 0x7fffffffffffffffLL;
for(int i=0; i<3; i++) {
convert->fromULong(pvBytePtr, ulval);
builder.clear(); pvBytePtr->toString(&builder);
if(debug) fprintf(fd,"byte %s\n",builder.c_str());
convert->fromULong(pvUBytePtr, ulval);
builder.clear(); pvUBytePtr->toString(&builder);
if(debug) fprintf(fd,"ubyte %s\n",builder.c_str());
convert->fromULong(pvShortPtr, ulval);
builder.clear(); pvShortPtr->toString(&builder);
if(debug) fprintf(fd,"short %s\n",builder.c_str());
convert->fromULong(pvUShortPtr, ulval);
builder.clear(); pvUShortPtr->toString(&builder);
if(debug) fprintf(fd,"ushort %s\n",builder.c_str());
convert->fromULong(pvIntPtr, ulval);
builder.clear(); pvIntPtr->toString(&builder);
if(debug) fprintf(fd,"int %s\n",builder.c_str());
convert->fromULong(pvUIntPtr, ulval);
builder.clear(); pvUIntPtr->toString(&builder);
if(debug) fprintf(fd,"uint %s\n",builder.c_str());
convert->fromULong(pvLongPtr, ulval);
builder.clear(); pvLongPtr->toString(&builder);
if(debug) fprintf(fd,"long %s\n",builder.c_str());
convert->fromULong(pvULongPtr, ulval);
builder.clear(); pvULongPtr->toString(&builder);
if(debug) fprintf(fd,"ulong %s\n",builder.c_str());
convert->fromULong(pvFloatPtr, ulval);
builder.clear(); pvFloatPtr->toString(&builder);
if(debug) fprintf(fd,"float %s\n",builder.c_str());
convert->fromULong(pvDoublePtr, ulval);
builder.clear(); pvDoublePtr->toString(&builder);
if(debug) fprintf(fd,"double %s\n",builder.c_str());
convert->copyScalar(pvULongPtr, pvFloatPtr);
builder.clear(); pvFloatPtr->toString(&builder);
if(debug) fprintf(fd,"float from unsigned %s\n",builder.c_str());
convert->copyScalar(pvULongPtr, pvDoublePtr);
builder.clear(); pvDoublePtr->toString(&builder);
if(debug) fprintf(fd,"double from unsigned %s\n",builder.c_str());
ulval++;
}
fprintf(fd,"fromULong PASSED\n");
}
