epics/pvAccess
0
0
Fork 0
Code Issues Pull Requests Projects Wiki Activity

implement field options

Browse Source
This commit is contained in:
mrkraimer
2018-09-27 10:02:00 -04:00
parent e9d2114e96
commit 1204874481
4 changed files with 235 additions and 18 deletions
Download Patch File Download Diff File Expand all files Collapse all files

231
src/ca/dbdToPv.cpp
View File

@@ -46,6 +46,11 @@ DbdToPvPtr DbdToPv::create(
DbdToPv::DbdToPv(IOType ioType)
: ioType(ioType),
dbfIsUCHAR(false),
dbfIsUSHORT(false),
dbfIsULONG(false),
dbfIsINT64(false),
dbfIsUINT64(false),
valueRequested(false),
alarmRequested(false),
timeStampRequested(false),
@@ -53,6 +58,7 @@ DbdToPv::DbdToPv(IOType ioType)
controlRequested(false),
valueAlarmRequested(false),
isArray(false),
charArrayIsString(false),
firstTime(true),
caValueType(-1),
caRequestType(-1),
@@ -79,10 +85,15 @@ static chtype getDbrType(const ScalarType scalarType)
{
case pvString : return DBR_STRING;
case pvByte : return DBR_CHAR;
case pvUByte : return DBR_CHAR;
case pvShort : return DBR_SHORT;
case pvUShort : return DBR_SHORT;
case pvInt : return DBR_LONG;
case pvUInt : return DBR_LONG;
case pvFloat : return DBR_FLOAT;
case pvDouble : return DBR_DOUBLE;
case pvLong : return DBR_DOUBLE;
case pvULong : return DBR_DOUBLE;
default: break;
}
throw std::runtime_error("getDbr: illegal scalarType");
@@ -196,25 +207,72 @@ void DbdToPv::activate(
return;
}
ScalarType st = dbr2ST[channelType];
PVStringPtr pvValue = fieldPVStructure->getSubField<PVString>("value._options.dbtype");
if(pvValue)
{
std::string value(pvValue->get());
if(value.find("DBF_UCHAR")!=std::string::npos) {
if(st==pvByte) {
dbfIsUCHAR = true;
st = pvUByte;
caValueType = DBR_CHAR;
}
} else if(value.find("DBF_USHORT")!=std::string::npos) {
if(st==pvInt) {
dbfIsUSHORT = true;
st = pvUShort;
caValueType = DBR_SHORT;
}
} else if(value.find("DBF_ULONG")!=std::string::npos) {
if(st==pvDouble) {
dbfIsULONG = true;
st = pvUInt;
caValueType = DBR_LONG;
}
} else if(value.find("DBF_INT64")!=std::string::npos) {
if(st==pvDouble) {
dbfIsINT64 = true;
st = pvLong;
}
} else if(value.find("DBF_UINT64")!=std::string::npos) {
if(st==pvDouble) {
dbfIsUINT64 = true;
st = pvULong;
}
}
}
if(st==pvString) {
displayRequested = false;
controlRequested = false;
valueAlarmRequested = false;
}
maxElements = ca_element_count(channelID);
if(maxElements!=1) isArray = true;
if(isArray)
{
controlRequested = false;
valueAlarmRequested = false;
if(channelType==DBR_CHAR && fieldPVStructure)
{
PVStringPtr pvValue = fieldPVStructure->getSubField<PVString>("value._options.pvtype");
if(pvValue) {
std::string value(pvValue->get());
if(value.find("pvString")!=std::string::npos) {
charArrayIsString = true;
st = pvString;
}
}
}
}
ScalarType st = dbr2ST[channelType];
if(st==pvString) {
displayRequested = false;
controlRequested = false;
valueAlarmRequested = false;
}
if(controlRequested || displayRequested || valueAlarmRequested) timeStampRequested = false;
FieldCreatePtr fieldCreate(FieldCreate::getFieldCreate());
PVDataCreatePtr pvDataCreate(PVDataCreate::getPVDataCreate());
FieldBuilderPtr fieldBuilder(fieldCreate->createFieldBuilder());
if(valueRequested) {
if(isArray) {
if(isArray && !charArrayIsString) {
fieldBuilder->addArray("value",st);
} else {
fieldBuilder->add("value",st);
@@ -228,14 +286,19 @@ void DbdToPv::activate(
switch(st)
{
case pvByte:
case pvUByte:
fieldBuilder->add("valueAlarm",standardField->byteAlarm()); break;
case pvShort:
case pvUShort:
fieldBuilder->add("valueAlarm",standardField->shortAlarm()); break;
case pvInt:
case pvUInt:
fieldBuilder->add("valueAlarm",standardField->intAlarm()); break;
case pvFloat:
fieldBuilder->add("valueAlarm",standardField->floatAlarm()); break;
case pvDouble:
case pvLong:
case pvULong:
fieldBuilder->add("valueAlarm",standardField->doubleAlarm()); break;
default:
throw std::runtime_error("DbDToPv::activate: bad type");
@@ -392,18 +455,51 @@ Status DbdToPv::getFromDBD(
break;
}
case DBR_CHAR:
if(charArrayIsString)
{
const char * pchar = static_cast<const char *>(value);
std::string str(pchar);
PVStringPtr pvValue(pvStructure->getSubField<PVString>("value"));
pvValue->put(str);
break;
}
if(dbfIsUCHAR)
{
copy_DBRScalarArray<dbr_char_t,PVUByteArray>(value,count,pvValue);
break;
}
copy_DBRScalarArray<dbr_char_t,PVByteArray>(value,count,pvValue);
break;
case DBR_SHORT:
if(dbfIsUSHORT)
{
copy_DBRScalarArray<dbr_short_t,PVUShortArray>(value,count,pvValue);
break;
}
copy_DBRScalarArray<dbr_short_t,PVShortArray>(value,count,pvValue);
break;
case DBR_LONG:
if(dbfIsULONG)
{
copy_DBRScalarArray<dbr_long_t,PVUIntArray>(value,count,pvValue);
break;
}
copy_DBRScalarArray<dbr_long_t,PVIntArray>(value,count,pvValue);
break;
case DBR_FLOAT:
copy_DBRScalarArray<dbr_float_t,PVFloatArray>(value,count,pvValue);
break;
case DBR_DOUBLE:
if(dbfIsINT64)
{
copy_DBRScalarArray<dbr_double_t,PVLongArray>(value,count,pvValue);
break;
}
if(dbfIsUINT64)
{
copy_DBRScalarArray<dbr_double_t,PVULongArray>(value,count,pvValue);
break;
}
copy_DBRScalarArray<dbr_double_t,PVDoubleArray>(value,count,pvValue);
break;
default:
@@ -434,11 +530,40 @@ Status DbdToPv::getFromDBD(
break;
}
case DBR_STRING: copy_DBRScalar<dbr_string_t,PVString>(value,pvValue); break;
case DBR_CHAR: copy_DBRScalar<dbr_char_t,PVByte>(value,pvValue); break;
case DBR_SHORT: copy_DBRScalar<dbr_short_t,PVShort>(value,pvValue); break;
case DBR_LONG: copy_DBRScalar<dbr_long_t,PVInt>(value,pvValue); break;
case DBR_CHAR:
if(dbfIsUCHAR)
{
copy_DBRScalar<dbr_char_t,PVUByte>(value,pvValue);
break;
}
copy_DBRScalar<dbr_char_t,PVByte>(value,pvValue); break;
case DBR_SHORT:
if(dbfIsUSHORT)
{
copy_DBRScalar<dbr_short_t,PVUShort>(value,pvValue);
break;
}
copy_DBRScalar<dbr_short_t,PVShort>(value,pvValue); break;
case DBR_LONG:
if(dbfIsULONG)
{
copy_DBRScalar<dbr_long_t,PVUInt>(value,pvValue);
break;
}
copy_DBRScalar<dbr_long_t,PVInt>(value,pvValue); break;
case DBR_FLOAT: copy_DBRScalar<dbr_float_t,PVFloat>(value,pvValue); break;
case DBR_DOUBLE: copy_DBRScalar<dbr_double_t,PVDouble>(value,pvValue); break;
case DBR_DOUBLE:
if(dbfIsINT64)
{
copy_DBRScalar<dbr_double_t,PVLong>(value,pvValue);
break;
}
if(dbfIsUINT64)
{
copy_DBRScalar<dbr_double_t,PVULong>(value,pvValue);
break;
}
copy_DBRScalar<dbr_double_t,PVDouble>(value,pvValue); break;
default:
Status errorStatus(
Status::STATUSTYPE_ERROR, string("DbdToPv::getFromDBD logic error"));
@@ -726,18 +851,63 @@ Status DbdToPv::putToDBD(
break;
}
case DBR_CHAR:
if(charArrayIsString)
{
PVStringPtr pvValue(pvStructure->getSubField<PVString>("value"));
const char * pchar = pvValue->get().c_str();
pValue = pchar;
count = pvValue->get().length();
break;
}
if(dbfIsUCHAR)
{
pValue = put_DBRScalarArray<dbr_char_t,PVUByteArray>(&count,pvValue);
break;
}
pValue = put_DBRScalarArray<dbr_char_t,PVByteArray>(&count,pvValue);
break;
case DBR_SHORT:
if(dbfIsUSHORT)
{
pValue = put_DBRScalarArray<dbr_short_t,PVUShortArray>(&count,pvValue);
break;
}
pValue = put_DBRScalarArray<dbr_short_t,PVShortArray>(&count,pvValue);
break;
case DBR_LONG:
if(dbfIsULONG)
{
pValue = put_DBRScalarArray<dbr_long_t,PVUIntArray>(&count,pvValue);
break;
}
pValue = put_DBRScalarArray<dbr_long_t,PVIntArray>(&count,pvValue);
break;
case DBR_FLOAT:
pValue = put_DBRScalarArray<dbr_float_t,PVFloatArray>(&count,pvValue);
break;
case DBR_DOUBLE:
if(dbfIsINT64)
{
PVLongArrayPtr pvValue(pvStructure->getSubField<PVLongArray>("value"));
PVLongArray::const_svector sv(pvValue->view());
pvDoubleArray = PVDoubleArrayPtr(getPVDataCreate()->createPVScalarArray<PVDoubleArray>());
pvDoubleArray->putFrom(sv);
const double * pdouble = pvDoubleArray->view().data();
count = pvValue->getLength();
pValue = pdouble;
break;
}
if(dbfIsUINT64)
{
PVULongArrayPtr pvValue(pvStructure->getSubField<PVULongArray>("value"));
PVULongArray::const_svector sv(pvValue->view());
pvDoubleArray = PVDoubleArrayPtr(getPVDataCreate()->createPVScalarArray<PVDoubleArray>());
pvDoubleArray->putFrom(sv);
const double * pdouble = pvDoubleArray->view().data();
count = pvValue->getLength();
pValue = pdouble;
break;
}
pValue = put_DBRScalarArray<dbr_double_t,PVDoubleArray>(&count,pvValue);
break;
default:
@@ -755,14 +925,43 @@ Status DbdToPv::putToDBD(
break;
}
case DBR_STRING: pValue = pvStructure->getSubField<PVString>("value")->get().c_str(); break;
case DBR_CHAR: pValue = put_DBRScalar<dbr_char_t,PVByte>(&bvalue,pvValue); break;
case DBR_SHORT: pValue = put_DBRScalar<dbr_short_t,PVShort>(&svalue,pvValue); break;
case DBR_LONG: pValue = put_DBRScalar<dbr_long_t,PVInt>(&lvalue,pvValue); break;
case DBR_CHAR:
if(dbfIsUCHAR)
{
pValue = put_DBRScalar<dbr_char_t,PVUByte>(&bvalue,pvValue);
break;
}
pValue = put_DBRScalar<dbr_char_t,PVByte>(&bvalue,pvValue); break;
case DBR_SHORT:
if(dbfIsUSHORT)
{
pValue = put_DBRScalar<dbr_short_t,PVUShort>(&svalue,pvValue);
break;
}
pValue = put_DBRScalar<dbr_short_t,PVShort>(&svalue,pvValue); break;
case DBR_LONG:
if(dbfIsULONG)
{
pValue = put_DBRScalar<dbr_long_t,PVUInt>(&lvalue,pvValue);
break;
}
pValue = put_DBRScalar<dbr_long_t,PVInt>(&lvalue,pvValue); break;
case DBR_FLOAT: pValue = put_DBRScalar<dbr_float_t,PVFloat>(&fvalue,pvValue); break;
case DBR_DOUBLE: pValue = put_DBRScalar<dbr_double_t,PVDouble>(&dvalue,pvValue); break;
case DBR_DOUBLE:
if(dbfIsINT64)
{
pValue = put_DBRScalar<dbr_double_t,PVLong>(&dvalue,pvValue);
break;
}
if(dbfIsUINT64)
{
pValue = put_DBRScalar<dbr_double_t,PVULong>(&dvalue,pvValue);
break;
}
pValue = put_DBRScalar<dbr_double_t,PVDouble>(&dvalue,pvValue); break;
default:
Status errorStatus(
Status::STATUSTYPE_ERROR, string("DbdToPv::getFromDBD logic error"));
Status::STATUSTYPE_ERROR, string("DbdToPv::putToDBD logic error"));
return errorStatus;
}
}