731 lines
21 KiB
C++
731 lines
21 KiB
C++
|
|
#include <dbAccess.h>
|
|
|
|
#include <pv/pvIntrospect.h> /* for pvdVersion.h */
|
|
#include <pv/standardField.h>
|
|
|
|
#include <dbAccess.h>
|
|
#include <dbChannel.h>
|
|
#include <dbStaticLib.h>
|
|
#include <dbLock.h>
|
|
#include <dbEvent.h>
|
|
|
|
#include <pv/bitSet.h>
|
|
#include <pv/pvData.h>
|
|
|
|
#define epicsExportSharedSymbols
|
|
#include "pvif.h"
|
|
|
|
namespace pvd = epics::pvData;
|
|
|
|
DBCH::DBCH(dbChannel *ch) :chan(ch)
|
|
{
|
|
if(dbChannelOpen(chan)) {
|
|
dbChannelDelete(chan);
|
|
throw std::invalid_argument("Failed to open channel");
|
|
}
|
|
if(!chan)
|
|
throw std::invalid_argument(std::string("Invalid channel ")+dbChannelName(ch));
|
|
}
|
|
|
|
DBCH::DBCH(const std::string& name)
|
|
:chan(dbChannelCreate(name.c_str()))
|
|
{
|
|
if(!chan)
|
|
throw std::invalid_argument("Invalid channel");
|
|
if(dbChannelOpen(chan)) {
|
|
dbChannelDelete(chan);
|
|
throw std::invalid_argument("Failed to open channel "+name);
|
|
}
|
|
}
|
|
|
|
DBCH::DBCH(const char *name)
|
|
:chan(dbChannelCreate(name))
|
|
{
|
|
if(!chan)
|
|
throw std::invalid_argument("Invalid channel");
|
|
if(dbChannelOpen(chan)) {
|
|
dbChannelDelete(chan);
|
|
throw std::invalid_argument(std::string("Failed to open channel ")+name);
|
|
}
|
|
}
|
|
|
|
DBCH::~DBCH()
|
|
{
|
|
if(chan) dbChannelDelete(chan);
|
|
}
|
|
|
|
void DBCH::swap(DBCH& o)
|
|
{
|
|
std::swap(chan, o.chan);
|
|
}
|
|
|
|
PVIF::PVIF(dbChannel *ch)
|
|
:chan(ch)
|
|
{}
|
|
|
|
namespace {
|
|
|
|
struct pvCommon {
|
|
dbChannel *chan;
|
|
|
|
pvd::uint32 nsecMask;
|
|
|
|
pvd::BitSet maskALWAYS, maskVALUE, maskALARM, maskPROPERTY,
|
|
maskVALUEPut;
|
|
|
|
pvd::PVLongPtr sec;
|
|
pvd::PVIntPtr status, severity, nsec, userTag;
|
|
|
|
pvd::PVDoublePtr displayLow, displayHigh, controlLow, controlHigh;
|
|
pvd::PVStringPtr egu;
|
|
|
|
pvd::PVScalarPtr warnLow, warnHigh, alarmLow, alarmHigh;
|
|
|
|
pvd::PVScalarPtr prec;
|
|
|
|
pvd::PVStringArrayPtr enumopts;
|
|
|
|
pvCommon() :chan(NULL), nsecMask(0) {}
|
|
};
|
|
|
|
struct pvScalar : public pvCommon {
|
|
typedef pvd::PVScalar pvd_type;
|
|
pvd::PVScalarPtr value;
|
|
};
|
|
|
|
struct pvArray : public pvCommon {
|
|
typedef pvd::PVScalarArray pvd_type;
|
|
pvd::PVScalarArrayPtr value;
|
|
};
|
|
|
|
struct metaTIME {
|
|
DBRstatus
|
|
DBRtime
|
|
|
|
enum {mask = DBR_STATUS | DBR_TIME};
|
|
};
|
|
|
|
struct metaLONG {
|
|
DBRstatus
|
|
DBRunits
|
|
DBRtime
|
|
DBRgrLong
|
|
DBRctrlLong
|
|
DBRalLong
|
|
|
|
// included so that field is present, not actually used
|
|
// TODO: split up putMeta() to avoid this..
|
|
DBRprecision
|
|
DBRenumStrs
|
|
|
|
enum {mask = DBR_STATUS | DBR_UNITS | DBR_TIME | DBR_GR_LONG | DBR_CTRL_LONG | DBR_AL_LONG};
|
|
};
|
|
|
|
struct metaDOUBLE {
|
|
DBRstatus
|
|
DBRunits
|
|
DBRprecision
|
|
DBRtime
|
|
DBRgrDouble
|
|
DBRctrlDouble
|
|
DBRalDouble
|
|
|
|
// similar junk
|
|
DBRenumStrs
|
|
|
|
enum {mask = DBR_STATUS | DBR_UNITS | DBR_PRECISION | DBR_TIME | DBR_GR_DOUBLE | DBR_CTRL_DOUBLE | DBR_AL_DOUBLE};
|
|
};
|
|
|
|
struct metaENUM {
|
|
DBRstatus
|
|
DBRtime
|
|
DBRenumStrs
|
|
|
|
// similar junk
|
|
DBRunits
|
|
DBRprecision
|
|
DBRgrLong
|
|
DBRctrlLong
|
|
DBRalLong
|
|
|
|
enum {mask = DBR_STATUS | DBR_TIME | DBR_ENUM_STRS};
|
|
};
|
|
|
|
struct metaSTRING {
|
|
DBRstatus
|
|
DBRtime
|
|
|
|
// similar junk
|
|
DBRenumStrs
|
|
DBRunits
|
|
DBRprecision
|
|
DBRgrLong
|
|
DBRctrlLong
|
|
DBRalLong
|
|
|
|
enum {mask = DBR_STATUS | DBR_TIME};
|
|
};
|
|
|
|
// lookup fields and populate pvCommon. Non-existant fields will be NULL.
|
|
void attachMeta(pvCommon& pvm, const pvd::PVStructurePtr& pv)
|
|
{
|
|
#define FMAP(MNAME, PVT, FNAME, DBE) pvm.MNAME = pv->getSubField<pvd::PVT>(FNAME); \
|
|
if(pvm.MNAME) pvm.mask ## DBE.set(pvm.MNAME->getFieldOffset())
|
|
FMAP(status, PVInt, "alarm.status", ALARM);
|
|
FMAP(severity, PVInt, "alarm.severity", ALARM);
|
|
FMAP(sec, PVLong, "timeStamp.secondsPastEpoch", ALWAYS);
|
|
FMAP(nsec, PVInt, "timeStamp.nanoseconds", ALWAYS);
|
|
FMAP(displayHigh, PVDouble, "display.limitHigh", PROPERTY);
|
|
FMAP(displayLow, PVDouble, "display.limitLow", PROPERTY);
|
|
FMAP(controlHigh, PVDouble, "control.limitHigh", PROPERTY);
|
|
FMAP(controlLow, PVDouble, "control.limitLow", PROPERTY);
|
|
FMAP(egu, PVString, "display.units", PROPERTY);
|
|
//FMAP(prec, PVScalar, "display.format", PROPERTY);
|
|
FMAP(warnHigh, PVScalar, "alarm.highWarningLimit", PROPERTY);
|
|
FMAP(warnLow, PVScalar, "alarm.lowWarningLimit", PROPERTY);
|
|
FMAP(alarmHigh, PVScalar, "alarm.highAlarmLimit", PROPERTY);
|
|
FMAP(alarmLow, PVScalar, "alarm.lowAlarmLimit", PROPERTY);
|
|
FMAP(enumopts, PVStringArray, "value.choices", PROPERTY);
|
|
#undef FMAP
|
|
assert(pvm.status && pvm.severity && pvm.sec && pvm.nsec);
|
|
}
|
|
|
|
template<typename PVM>
|
|
void attachAll(PVM& pvm, const pvd::PVStructurePtr& pv)
|
|
{
|
|
pvm.value = pv->getSubField<typename PVM::pvd_type>("value.index");
|
|
if(!pvm.value)
|
|
pvm.value = pv->getSubFieldT<typename PVM::pvd_type>("value");
|
|
const pvd::PVField *fld = pvm.value.get();
|
|
pvm.maskVALUE.set(fld->getFieldOffset());
|
|
for(;fld; fld = fld->getParent()) {
|
|
// set field bit and all enclosing structure bits
|
|
pvm.maskVALUEPut.set(fld->getFieldOffset());
|
|
}
|
|
attachMeta(pvm, pv);
|
|
}
|
|
|
|
void putTime(const pvCommon& pv, unsigned dbe, db_field_log *pfl)
|
|
{
|
|
metaTIME meta;
|
|
long options = (int)metaTIME::mask, nReq = 0;
|
|
|
|
long status = dbChannelGet(pv.chan, dbChannelFinalFieldType(pv.chan), &meta, &options, &nReq, pfl);
|
|
if(status)
|
|
throw std::runtime_error("dbGet for meta fails");
|
|
|
|
pvd::int32 nsec = meta.time.nsec;
|
|
if(pv.nsecMask) {
|
|
pv.userTag->put(nsec&pv.nsecMask);
|
|
nsec &= ~pv.nsecMask;
|
|
}
|
|
pv.nsec->put(nsec); pv.sec->put(meta.time.secPastEpoch+POSIX_TIME_AT_EPICS_EPOCH);
|
|
if(dbe&DBE_ALARM) {
|
|
//pv.status->put(meta.status);
|
|
pv.severity->put(meta.severity);
|
|
}
|
|
}
|
|
|
|
void putValue(dbChannel *chan, pvd::PVScalar* value, db_field_log *pfl)
|
|
{
|
|
dbrbuf buf;
|
|
long nReq = 1;
|
|
|
|
long status = dbChannelGet(chan, dbChannelFinalFieldType(chan), &buf, NULL, &nReq, pfl);
|
|
if(status)
|
|
throw std::runtime_error("dbGet for meta fails");
|
|
|
|
switch(dbChannelFinalFieldType(chan)) {
|
|
#define CASE(FTYPE) case DBR_##FTYPE: value->putFrom(buf.dbf_##FTYPE); break
|
|
CASE(CHAR);
|
|
CASE(UCHAR);
|
|
CASE(SHORT);
|
|
CASE(USHORT);
|
|
CASE(ENUM);
|
|
CASE(LONG);
|
|
CASE(ULONG);
|
|
CASE(FLOAT);
|
|
CASE(DOUBLE);
|
|
#undef CASE
|
|
case DBR_STRING:
|
|
buf.dbf_STRING[sizeof(buf.dbf_STRING)-1] = '\0';
|
|
value->putFrom<std::string>(buf.dbf_STRING);
|
|
break;
|
|
default:
|
|
throw std::runtime_error("putValue unsupported DBR code");
|
|
}
|
|
}
|
|
|
|
void getValue(dbChannel *chan, pvd::PVScalar* value)
|
|
{
|
|
dbrbuf buf;
|
|
|
|
switch(dbChannelFinalFieldType(chan)) {
|
|
#define CASE(FTYPE, PTYPE) case DBR_##FTYPE: buf.dbf_##FTYPE = value->getAs<PTYPE>(); break
|
|
CASE(CHAR, pvd::int8);
|
|
CASE(UCHAR, pvd::uint8);
|
|
CASE(SHORT, pvd::int16);
|
|
CASE(USHORT, pvd::uint16);
|
|
CASE(LONG, pvd::int32);
|
|
CASE(ULONG, pvd::uint32);
|
|
CASE(FLOAT, float);
|
|
CASE(ENUM, pvd::int16);
|
|
CASE(DOUBLE, double);
|
|
#undef CASE
|
|
case DBR_STRING:
|
|
{
|
|
std::string val(value->getAs<std::string>());
|
|
strncpy(buf.dbf_STRING, val.c_str(), sizeof(buf.dbf_STRING));
|
|
buf.dbf_STRING[sizeof(buf.dbf_STRING)-1] = '\0';
|
|
}
|
|
break;
|
|
default:
|
|
throw std::runtime_error("getValue unsupported DBR code");
|
|
}
|
|
|
|
long status = dbChannelPut(chan, dbChannelFinalFieldType(chan), &buf, 1);
|
|
if(status)
|
|
throw std::runtime_error("dbPut for meta fails");
|
|
}
|
|
|
|
void getValue(dbChannel *chan, pvd::PVScalarArray* value)
|
|
{
|
|
short dbr = dbChannelFinalFieldType(chan);
|
|
pvd::shared_vector<const void> buf;
|
|
|
|
assert(dbr!=DBR_STRING);
|
|
|
|
value->getAs(buf);
|
|
long nReq = buf.size()/pvd::ScalarTypeFunc::elementSize(value->getScalarArray()->getElementType());
|
|
|
|
long status = dbChannelPut(chan, dbr, buf.data(), nReq);
|
|
if(status)
|
|
throw std::runtime_error("dbChannelPut for meta fails");
|
|
}
|
|
|
|
void putValue(dbChannel *chan, pvd::PVScalarArray* value, db_field_log *pfl)
|
|
{
|
|
const short dbr = dbChannelFinalFieldType(chan);
|
|
|
|
long nReq = dbChannelFinalElements(chan);
|
|
const pvd::ScalarType etype = value->getScalarArray()->getElementType();
|
|
|
|
assert(dbr!=DBR_STRING);
|
|
|
|
pvd::shared_vector<void> buf(pvd::ScalarTypeFunc::allocArray(etype, nReq)); // TODO: pool?
|
|
|
|
long status = dbChannelGet(chan, dbr, buf.data(), NULL, &nReq, pfl);
|
|
if(status)
|
|
throw std::runtime_error("dbChannelGet for meta fails");
|
|
|
|
buf.slice(0, nReq*pvd::ScalarTypeFunc::elementSize(etype));
|
|
|
|
value->putFrom(pvd::freeze(buf));
|
|
}
|
|
|
|
template<typename META>
|
|
void putMeta(const pvCommon& pv, unsigned dbe, db_field_log *pfl)
|
|
{
|
|
META meta;
|
|
long options = (int)META::mask, nReq = 0;
|
|
|
|
long status = dbChannelGet(pv.chan, dbChannelFinalFieldType(pv.chan), &meta, &options, &nReq, pfl);
|
|
if(status)
|
|
throw std::runtime_error("dbGet for meta fails");
|
|
|
|
pvd::int32 nsec = meta.time.nsec;
|
|
if(pv.nsecMask) {
|
|
pv.userTag->put(nsec&pv.nsecMask);
|
|
nsec &= ~pv.nsecMask;
|
|
}
|
|
pv.nsec->put(nsec);
|
|
#define FMAP(MNAME, FNAME) pv.MNAME->put(meta.FNAME)
|
|
FMAP(sec, time.secPastEpoch+POSIX_TIME_AT_EPICS_EPOCH);
|
|
if(dbe&DBE_ALARM) {
|
|
//FMAP(status, status);
|
|
FMAP(severity, severity);
|
|
}
|
|
if(dbe&DBE_PROPERTY) {
|
|
#undef FMAP
|
|
#define FMAP(MASK, MNAME, FNAME) if(META::mask&(MASK) && pv.MNAME) pv.MNAME->put(meta.FNAME)
|
|
FMAP(DBR_GR_DOUBLE|DBR_GR_LONG, displayHigh, upper_disp_limit);
|
|
FMAP(DBR_GR_DOUBLE|DBR_GR_LONG, displayLow, lower_disp_limit);
|
|
FMAP(DBR_CTRL_DOUBLE|DBR_CTRL_DOUBLE, controlHigh, upper_ctrl_limit);
|
|
FMAP(DBR_CTRL_DOUBLE|DBR_CTRL_DOUBLE, controlLow, lower_ctrl_limit);
|
|
FMAP(DBR_GR_DOUBLE|DBR_GR_LONG, egu, units);
|
|
#undef FMAP
|
|
#define FMAP(MASK, MNAME, FNAME) if(META::mask&(MASK) && pv.MNAME) pv.MNAME->putFrom(meta.FNAME)
|
|
// not handling precision until I get a better idea of what 'format' is supposed to be...
|
|
//FMAP(prec, PVScalar, "display.format", PROPERTY);
|
|
FMAP(DBR_AL_DOUBLE|DBR_AL_DOUBLE, warnHigh, upper_warning_limit);
|
|
FMAP(DBR_AL_DOUBLE|DBR_AL_DOUBLE, warnLow, lower_warning_limit);
|
|
FMAP(DBR_AL_DOUBLE|DBR_AL_DOUBLE, alarmHigh, upper_alarm_limit);
|
|
FMAP(DBR_AL_DOUBLE|DBR_AL_DOUBLE, alarmLow, lower_alarm_limit);
|
|
#undef FMAP
|
|
if(pv.enumopts) {
|
|
pvd::shared_vector<std::string> strs(meta.no_str);
|
|
for(size_t i=0; i<strs.size(); i++)
|
|
{
|
|
meta.strs[i][sizeof(meta.strs[i])-1] = '\0';
|
|
strs[i] = meta.strs[i];
|
|
}
|
|
pv.enumopts->replace(pvd::freeze(strs));
|
|
}
|
|
}
|
|
}
|
|
|
|
template<typename PVC, typename META>
|
|
void putAll(const PVC &pv, unsigned dbe, db_field_log *pfl)
|
|
{
|
|
if(dbe&(DBE_VALUE|DBE_ARCHIVE)) {
|
|
putValue(pv.chan, pv.value.get(), pfl);
|
|
}
|
|
if(!(dbe&DBE_PROPERTY)) {
|
|
putTime(pv, dbe, pfl);
|
|
} else {
|
|
putMeta<META>(pv, dbe, pfl);
|
|
}
|
|
}
|
|
|
|
template<class PVM, typename META>
|
|
struct PVIFScalarNumeric : public PVIF
|
|
{
|
|
PVM pvmeta;
|
|
const epics::pvData::PVStructurePtr pvalue;
|
|
|
|
PVIFScalarNumeric(dbChannel *ch, const epics::pvData::PVFieldPtr& p, pvd::PVField *enclosing)
|
|
:PVIF(ch)
|
|
,pvalue(std::tr1::dynamic_pointer_cast<pvd::PVStructure>(p))
|
|
{
|
|
if(!pvalue)
|
|
throw std::runtime_error("Must attach to structure");
|
|
pdbRecordIterator info(chan);
|
|
|
|
pvmeta.chan = ch;
|
|
attachAll(pvmeta, pvalue);
|
|
if(enclosing) {
|
|
size_t bit = enclosing->getFieldOffset();
|
|
// we are inside a structure array or similar with only one bit for all ours fields
|
|
pvmeta.maskALWAYS.clear();
|
|
pvmeta.maskALWAYS.set(bit);
|
|
pvmeta.maskVALUE.clear();
|
|
pvmeta.maskVALUE.set(bit);
|
|
pvmeta.maskALARM.clear();
|
|
pvmeta.maskALARM.set(bit);
|
|
pvmeta.maskPROPERTY.clear();
|
|
pvmeta.maskPROPERTY.set(bit);
|
|
pvmeta.maskVALUEPut.clear();
|
|
pvmeta.maskVALUEPut.set(bit);
|
|
}
|
|
const char *UT = info.info("pdbUserTag");
|
|
if(UT && strncmp(UT, "nslsb", 5)==0) {
|
|
try{
|
|
pvmeta.nsecMask = epics::pvData::castUnsafe<unsigned>(std::string(&UT[5]));
|
|
}catch(std::exception& e){
|
|
std::cerr<<dbChannelRecord(ch)->name<<" : pdbUserTag nslsb requires a number not '"<<UT[5]<<"'\n";
|
|
}
|
|
}
|
|
if(pvmeta.nsecMask>0 && pvmeta.nsecMask<=32) {
|
|
pvmeta.userTag = pvalue->getSubField<pvd::PVInt>("timeStamp.userTag");
|
|
if(!pvmeta.userTag) {
|
|
pvmeta.nsecMask = 0; // struct doesn't have userTag
|
|
} else {
|
|
pvd::uint64 mask = (1<<pvmeta.nsecMask)-1;
|
|
pvmeta.nsecMask = mask;
|
|
pvmeta.maskALWAYS.set(pvmeta.userTag->getFieldOffset());
|
|
}
|
|
} else
|
|
pvmeta.nsecMask = 0;
|
|
}
|
|
virtual ~PVIFScalarNumeric() {}
|
|
|
|
virtual void put(epics::pvData::BitSet& mask, unsigned dbe, db_field_log *pfl) OVERRIDE FINAL
|
|
{
|
|
try{
|
|
putAll<PVM, META>(pvmeta, dbe, pfl);
|
|
mask |= pvmeta.maskALWAYS;
|
|
if(dbe&(DBE_VALUE|DBE_ARCHIVE))
|
|
mask |= pvmeta.maskVALUE;
|
|
if(dbe&DBE_ALARM)
|
|
mask |= pvmeta.maskALARM;
|
|
if(dbe&DBE_PROPERTY)
|
|
mask |= pvmeta.maskPROPERTY;
|
|
}catch(...){
|
|
pvmeta.severity->put(3);
|
|
mask |= pvmeta.maskALARM;
|
|
throw;
|
|
}
|
|
}
|
|
|
|
virtual void get(const epics::pvData::BitSet& mask) OVERRIDE FINAL
|
|
{
|
|
if(mask.logical_and(pvmeta.maskVALUEPut))
|
|
getValue(pvmeta.chan, pvmeta.value.get());
|
|
}
|
|
|
|
virtual unsigned dbe(const epics::pvData::BitSet& mask) OVERRIDE FINAL
|
|
{
|
|
unsigned ret = 0;
|
|
if(mask.logical_and(pvmeta.maskVALUE))
|
|
ret |= DBE_VALUE;
|
|
if(mask.logical_and(pvmeta.maskALARM))
|
|
ret |= DBE_ALARM;
|
|
if(mask.logical_and(pvmeta.maskPROPERTY))
|
|
ret |= DBE_PROPERTY;
|
|
return ret;
|
|
}
|
|
};
|
|
|
|
} // namespace
|
|
|
|
pvd::ScalarType DBR2PVD(short dbr)
|
|
{
|
|
switch(dbr) {
|
|
#define CASE(BASETYPE, PVATYPE, DBFTYPE, PVACODE) case DBR_##DBFTYPE: return pvd::pv##PVACODE;
|
|
#define CASE_ENUM
|
|
#define CASE_SKIP_BOOL
|
|
#include "pvatypemap.h"
|
|
#undef CASE_ENUM
|
|
#undef CASE_SKIP_BOOL
|
|
#undef CASE
|
|
case DBF_STRING: return pvd::pvString;
|
|
default:
|
|
throw std::invalid_argument("Unsupported DBR code");
|
|
}
|
|
}
|
|
|
|
short PVD2DBR(pvd::ScalarType pvt)
|
|
{
|
|
switch(pvt) {
|
|
#define CASE(BASETYPE, PVATYPE, DBFTYPE, PVACODE) case pvd::pv##PVACODE: return DBR_##DBFTYPE;
|
|
#define CASE_SQUEEZE_INT64
|
|
#include "pvatypemap.h"
|
|
#undef CASE_SQUEEZE_INT64
|
|
#undef CASE
|
|
default:
|
|
throw std::invalid_argument("Unsupported pvType code");
|
|
}
|
|
}
|
|
|
|
epics::pvData::FieldConstPtr
|
|
ScalarBuilder::dtype(dbChannel *channel)
|
|
{
|
|
const short dbr = dbChannelFinalFieldType(channel);
|
|
const long maxelem = dbChannelFinalElements(channel);
|
|
const pvd::ScalarType pvt = DBR2PVD(dbr);
|
|
|
|
if(INVALID_DB_REQ(dbr))
|
|
throw std::invalid_argument("DBF code out of range");
|
|
if(maxelem!=1 && dbr==DBR_STRING)
|
|
throw std::invalid_argument("String array not supported");
|
|
if(maxelem!=1 && dbr==DBR_ENUM)
|
|
throw std::invalid_argument("enum array not supported");
|
|
|
|
if(dbr==DBR_ENUM)
|
|
return pvd::getStandardField()->enumerated("alarm,timeStamp");
|
|
|
|
//TODO: ,valueAlarm for numeric
|
|
std::string options("alarm,timeStamp,display,control");
|
|
|
|
if(maxelem==1)
|
|
return pvd::getStandardField()->scalar(pvt, options);
|
|
else
|
|
return pvd::getStandardField()->scalarArray(pvt, options);
|
|
}
|
|
|
|
PVIF*
|
|
ScalarBuilder::attach(dbChannel *channel, const epics::pvData::PVStructurePtr& root, const FieldName& fldname)
|
|
{
|
|
if(!channel)
|
|
throw std::runtime_error("+type:\"scalar\" requires +channel:");
|
|
pvd::PVField *enclosing = 0;
|
|
pvd::PVFieldPtr fld(fldname.lookup(root, &enclosing));
|
|
|
|
const short dbr = dbChannelFinalFieldType(channel);
|
|
const long maxelem = dbChannelFinalElements(channel);
|
|
//const pvd::ScalarType pvt = DBR2PVD(dbr);
|
|
|
|
if(maxelem==1) {
|
|
switch(dbr) {
|
|
case DBR_CHAR:
|
|
case DBR_UCHAR:
|
|
case DBR_SHORT:
|
|
case DBR_USHORT:
|
|
case DBR_LONG:
|
|
case DBR_ULONG:
|
|
return new PVIFScalarNumeric<pvScalar, metaLONG>(channel, fld, enclosing);
|
|
case DBR_FLOAT:
|
|
case DBR_DOUBLE:
|
|
return new PVIFScalarNumeric<pvScalar, metaDOUBLE>(channel, fld, enclosing);
|
|
case DBR_ENUM:
|
|
return new PVIFScalarNumeric<pvScalar, metaENUM>(channel, fld, enclosing);
|
|
case DBR_STRING:
|
|
return new PVIFScalarNumeric<pvScalar, metaSTRING>(channel, fld, enclosing);
|
|
}
|
|
} else {
|
|
switch(dbr) {
|
|
case DBR_CHAR:
|
|
case DBR_UCHAR:
|
|
case DBR_SHORT:
|
|
case DBR_USHORT:
|
|
case DBR_LONG:
|
|
case DBR_ULONG:
|
|
return new PVIFScalarNumeric<pvArray, metaLONG>(channel, fld, enclosing);
|
|
case DBR_FLOAT:
|
|
case DBR_DOUBLE:
|
|
return new PVIFScalarNumeric<pvArray, metaDOUBLE>(channel, fld, enclosing);
|
|
}
|
|
}
|
|
|
|
throw std::invalid_argument("Channel has invalid/unsupported DBR type");
|
|
}
|
|
|
|
namespace {
|
|
template<class PVD>
|
|
struct PVIFPlain : public PVIF
|
|
{
|
|
const typename PVD::shared_pointer field;
|
|
size_t fieldOffset;
|
|
dbChannel * const channel;
|
|
|
|
PVIFPlain(dbChannel *channel, const epics::pvData::PVFieldPtr& fld, epics::pvData::PVField* enclosing=0)
|
|
:PVIF(channel)
|
|
,field(std::tr1::static_pointer_cast<PVD>(fld))
|
|
,channel(channel)
|
|
{
|
|
if(!field)
|
|
throw std::logic_error("PVIFPlain attached type mis-match");
|
|
if(enclosing)
|
|
fieldOffset = enclosing->getFieldOffset();
|
|
else
|
|
fieldOffset = field->getFieldOffset();
|
|
}
|
|
|
|
virtual ~PVIFPlain() {}
|
|
|
|
virtual void put(epics::pvData::BitSet& mask, unsigned dbe, db_field_log *pfl)
|
|
{
|
|
if(dbe&DBE_VALUE) {
|
|
putValue(channel, field.get(), pfl);
|
|
mask.set(fieldOffset);
|
|
}
|
|
}
|
|
|
|
virtual void get(const epics::pvData::BitSet& mask)
|
|
{
|
|
if(mask.get(fieldOffset))
|
|
getValue(channel, field.get());
|
|
}
|
|
|
|
virtual unsigned dbe(const epics::pvData::BitSet& mask)
|
|
{
|
|
if(mask.get(fieldOffset))
|
|
return DBE_VALUE;
|
|
return 0;
|
|
}
|
|
};
|
|
|
|
struct PlainBuilder : public PVIFBuilder
|
|
{
|
|
virtual ~PlainBuilder() {}
|
|
|
|
// fetch the structure description
|
|
virtual epics::pvData::FieldConstPtr dtype(dbChannel *channel) OVERRIDE FINAL {
|
|
const short dbr = dbChannelFinalFieldType(channel);
|
|
const long maxelem = dbChannelFinalElements(channel);
|
|
const pvd::ScalarType pvt = DBR2PVD(dbr);
|
|
|
|
if(INVALID_DB_REQ(dbr))
|
|
throw std::invalid_argument("DBF code out of range");
|
|
|
|
if(maxelem==1)
|
|
return pvd::getFieldCreate()->createScalar(pvt);
|
|
else
|
|
return pvd::getFieldCreate()->createScalarArray(pvt);
|
|
}
|
|
|
|
// Attach to a structure instance.
|
|
// must be of the type returned by dtype().
|
|
// need not be the root structure
|
|
virtual PVIF* attach(dbChannel *channel,
|
|
const epics::pvData::PVStructurePtr& root,
|
|
const FieldName& fldname) OVERRIDE FINAL
|
|
{
|
|
if(!channel)
|
|
throw std::runtime_error("+type:\"plain\" requires +channel:");
|
|
const long maxelem = dbChannelFinalElements(channel);
|
|
|
|
pvd::PVField *enclosing = 0;
|
|
pvd::PVFieldPtr fld(fldname.lookup(root, &enclosing));
|
|
|
|
if(maxelem==1)
|
|
return new PVIFPlain<pvd::PVScalar>(channel, fld, enclosing);
|
|
else
|
|
return new PVIFPlain<pvd::PVScalarArray>(channel, fld, enclosing);
|
|
}
|
|
};
|
|
|
|
struct AnyScalarBuilder : public PVIFBuilder
|
|
{
|
|
virtual ~AnyScalarBuilder() {}
|
|
|
|
// fetch the structure description
|
|
virtual epics::pvData::FieldConstPtr dtype(dbChannel *channel) OVERRIDE FINAL {
|
|
(void)channel; //ignored
|
|
return pvd::getFieldCreate()->createVariantUnion();
|
|
}
|
|
|
|
// Attach to a structure instance.
|
|
// must be of the type returned by dtype().
|
|
// need not be the root structure
|
|
virtual PVIF* attach(dbChannel *channel,
|
|
const epics::pvData::PVStructurePtr& root,
|
|
const FieldName& fldname) OVERRIDE FINAL
|
|
{
|
|
if(!channel)
|
|
throw std::runtime_error("+type:\"any\" requires +channel:");
|
|
pvd::PVDataCreatePtr create(pvd::getPVDataCreate());
|
|
const short dbr = dbChannelFinalFieldType(channel);
|
|
const long maxelem = dbChannelFinalElements(channel);
|
|
const pvd::ScalarType pvt = DBR2PVD(dbr);
|
|
|
|
pvd::PVField *enclosing = 0;
|
|
pvd::PVFieldPtr fld(fldname.lookup(root, &enclosing));
|
|
|
|
pvd::PVUnion *value = dynamic_cast<pvd::PVUnion*>(fld.get());
|
|
if(!value)
|
|
throw std::logic_error("Mis-matched attachment point");
|
|
|
|
pvd::PVFieldPtr arr(value->get());
|
|
if(!arr) {
|
|
if(maxelem==1)
|
|
arr = create->createPVScalar(pvt);
|
|
else
|
|
arr = create->createPVScalarArray(pvt);
|
|
value->set(arr);
|
|
}
|
|
|
|
if(maxelem==1)
|
|
return new PVIFPlain<pvd::PVScalar>(channel, arr, enclosing ? enclosing : arr.get());
|
|
else
|
|
return new PVIFPlain<pvd::PVScalarArray>(channel, arr, enclosing ? enclosing : arr.get());
|
|
}
|
|
|
|
};
|
|
|
|
}//namespace
|
|
|
|
|
|
PVIFBuilder* PVIFBuilder::create(const std::string& type)
|
|
{
|
|
if(type.empty() || type=="scalar")
|
|
return new ScalarBuilder;
|
|
else if(type=="plain")
|
|
return new PlainBuilder;
|
|
else if(type=="any")
|
|
return new AnyScalarBuilder;
|
|
else
|
|
throw std::runtime_error(std::string("Unknown +type=")+type);
|
|
}
|