This is Unofficial EPICS BASE Doxygen Site
Public Member Functions | Static Public Member Functions | List of all members
epics::pvAccess::ca::DbdToPv Class Reference

DbdToPv converts between DBD data and pvData. More...

#include "dbdToPv.h"

Public Member Functions

 POINTER_DEFINITIONS (DbdToPv)
 
epics::pvData::Structure::const_shared_pointer getStructure ()
 
void getChoices (CAChannelPtr const &caChannel)
 
epics::pvData::PVStructurePtr createPVStructure ()
 
chtype getRequestType ()
 
epics::pvData::Status getFromDBD (epics::pvData::PVStructurePtr const &pvStructure, epics::pvData::BitSet::shared_pointer const &bitSet, struct event_handler_args &args)
 
epics::pvData::Status putToDBD (CAChannelPtr const &caChannel, epics::pvData::PVStructurePtr const &pvStructure, bool block, caCallbackFunc putHandler, void *userArg)
 
void getChoicesDone (struct event_handler_args &args)
 

Static Public Member Functions

static DbdToPvPtr create (CAChannelPtr const &caChannel, epics::pvData::PVStructurePtr const &pvRequest, IOType ioType)
 

Detailed Description

DbdToPv converts between DBD data and pvData.

Definition at line 83 of file dbdToPv.h.

Member Function Documentation

DbdToPvPtr epics::pvAccess::ca::DbdToPv::create ( CAChannelPtr const &  caChannel,
epics::pvData::PVStructurePtr const &  pvRequest,
IOType  ioType 
)
static

Definition at line 37 of file dbdToPv.cpp.

41 {
42  DbdToPvPtr dbdToPv(new DbdToPv(ioType));
43  dbdToPv->activate(caChannel,pvRequest);
44  return dbdToPv;
45 }
epics::pvAccess::ca::DbdToPvPtr
std::tr1::shared_ptr< DbdToPv > DbdToPvPtr
Definition: dbdToPv.h:73
PVStructurePtr epics::pvAccess::ca::DbdToPv::createPVStructure ( )

Definition at line 377 of file dbdToPv.cpp.

378 {
379  return getPVDataCreate()->createPVStructure(structure);
380 }
epics::pvData::getPVDataCreate
FORCE_INLINE const PVDataCreatePtr & getPVDataCreate()
Definition: pvData.h:1648
void epics::pvAccess::ca::DbdToPv::getChoices ( CAChannelPtr const &  caChannel)

Definition at line 356 of file dbdToPv.cpp.

357 {
358  if(caRequestType==DBR_ENUM||caRequestType==DBR_TIME_ENUM)
359  {
360  caChannel->attachContext();
361  chid channelID = caChannel->getChannelID();
362  int result = ca_array_get_callback(DBR_GR_ENUM,
363  1,
364  channelID, enumChoicesHandler, this);
365  if (result == ECA_NORMAL) {
366  result = ca_flush_io();
367  choicesEvent.wait();
368  } else {
369  string mess(caChannel->getChannelName());
370  mess += " DbdToPv::activate getting enum cnoices ";
371  mess += ca_message(result);
372  throw std::runtime_error(mess);
373  }
374  }
375 }
ca_array_get_callback
LIBCA_API int epicsStdCall ca_array_get_callback(chtype type, unsigned long count, chid chanId, caEventCallBackFunc *pFunc, void *pArg)
Definition: oldChannelNotify.cpp:335
result
pvac::PutEvent result
Definition: clientSync.cpp:117
DBR_GR_ENUM
#define DBR_GR_ENUM
Definition: db_access.h:97
ECA_NORMAL
#define ECA_NORMAL
Definition: caerr.h:77
ca_flush_io
int epicsStdCall ca_flush_io()
Definition: access.cpp:509
DBR_TIME_ENUM
#define DBR_TIME_ENUM
Definition: db_access.h:89
DBR_ENUM
#define DBR_ENUM
Definition: db_access.h:73
ca_message
const char *epicsStdCall ca_message(long ca_status)
Definition: access.cpp:561
void epics::pvAccess::ca::DbdToPv::getChoicesDone ( struct event_handler_args &  args)

Definition at line 340 of file dbdToPv.cpp.

341 {
342  if(args.status!=ECA_NORMAL)
343  {
344  string message("DbdToPv::getChoicesDone ca_message ");
345  message += ca_message(args.status);
346  throw std::runtime_error(message);
347  }
348  const dbr_gr_enum* dbr_enum_p = static_cast<const dbr_gr_enum*>(args.dbr);
349  size_t num = dbr_enum_p->no_str;
350  choices.reserve(num);
351  for(size_t i=0; i<num; ++i) choices.push_back(string(&dbr_enum_p->strs[i][0]));
352  choicesEvent.signal();
353 }
event_handler_args::dbr
const void * dbr
Definition: cadef.h:89
i
int i
Definition: scan.c:967
ECA_NORMAL
#define ECA_NORMAL
Definition: caerr.h:77
dbr_gr_enum::no_str
dbr_short_t no_str
Definition: db_access.h:353
ca_message
const char *epicsStdCall ca_message(long ca_status)
Definition: access.cpp:561
event_handler_args::status
int status
Definition: cadef.h:90
dbr_gr_enum::strs
char strs[MAX_ENUM_STATES][MAX_ENUM_STRING_SIZE]
Definition: db_access.h:354
dbr_gr_enum
Definition: db_access.h:350
Status epics::pvAccess::ca::DbdToPv::getFromDBD ( epics::pvData::PVStructurePtr const &  pvStructure,
epics::pvData::BitSet::shared_pointer const &  bitSet,
struct event_handler_args &  args 
)

Definition at line 430 of file dbdToPv.cpp.

434 {
435  if(args.status!=ECA_NORMAL)
436  {
437  Status errorStatus(Status::STATUSTYPE_ERROR, string(ca_message(args.status)));
438  return errorStatus;
439  }
440  if(valueRequested)
441  {
442  void * value = dbr_value_ptr(args.dbr,caRequestType);
443  if(isArray) {
444  long count = args.count;
445  PVScalarArrayPtr pvValue = pvStructure->getSubField<PVScalarArray>("value");
446  switch(caValueType) {
447  case DBR_STRING:
448  {
449  const dbr_string_t *dbrval = static_cast<const dbr_string_t *>(value);
450  PVStringArrayPtr pvValue = pvStructure->getSubField<PVStringArray>("value");
451  PVStringArray::svector arr(pvValue->reuse());
452  arr.resize(count);
453  std::copy(dbrval, dbrval + count, arr.begin());
454  pvValue->replace(freeze(arr));
455  break;
456  }
457  case DBR_CHAR:
458  if(charArrayIsString)
459  {
460  const char * pchar = static_cast<const char *>(value);
461  std::string str(pchar);
462  PVStringPtr pvValue(pvStructure->getSubField<PVString>("value"));
463  pvValue->put(str);
464  break;
465  }
466  if(dbfIsUCHAR)
467  {
468  copy_DBRScalarArray<dbr_char_t,PVUByteArray>(value,count,pvValue);
469  break;
470  }
471  copy_DBRScalarArray<dbr_char_t,PVByteArray>(value,count,pvValue);
472  break;
473  case DBR_SHORT:
474  if(dbfIsUSHORT)
475  {
476  copy_DBRScalarArray<dbr_short_t,PVUShortArray>(value,count,pvValue);
477  break;
478  }
479  copy_DBRScalarArray<dbr_short_t,PVShortArray>(value,count,pvValue);
480  break;
481  case DBR_LONG:
482  if(dbfIsULONG)
483  {
484  copy_DBRScalarArray<dbr_long_t,PVUIntArray>(value,count,pvValue);
485  break;
486  }
487  copy_DBRScalarArray<dbr_long_t,PVIntArray>(value,count,pvValue);
488  break;
489  case DBR_FLOAT:
490  copy_DBRScalarArray<dbr_float_t,PVFloatArray>(value,count,pvValue);
491  break;
492  case DBR_DOUBLE:
493  if(dbfIsINT64)
494  {
495  copy_DBRScalarArray<dbr_double_t,PVLongArray>(value,count,pvValue);
496  break;
497  }
498  if(dbfIsUINT64)
499  {
500  copy_DBRScalarArray<dbr_double_t,PVULongArray>(value,count,pvValue);
501  break;
502  }
503  copy_DBRScalarArray<dbr_double_t,PVDoubleArray>(value,count,pvValue);
504  break;
505  default:
506  Status errorStatus(
507  Status::STATUSTYPE_ERROR, string("DbdToPv::getFromDBD logic error"));
508  return errorStatus;
509  }
510  } else {
511  PVScalarPtr pvValue = pvStructure->getSubField<PVScalar>("value");
512  switch(caValueType) {
513  case DBR_ENUM:
514  {
515  const dbr_enum_t *dbrval = static_cast<const dbr_enum_t *>(value);
516  PVIntPtr value = pvStructure->getSubField<PVInt>("value.index");
517  value->put(*dbrval);
518  PVStringArrayPtr pvChoices
519  = pvStructure->getSubField<PVStringArray>("value.choices");
520  if(pvChoices->getLength()==0)
521  {
522  ConvertPtr convert = getConvert();
523  size_t n = choices.size();
524  pvChoices->setLength(n);
525  convert->fromStringArray(pvChoices,0,n,choices,0);
526  bitSet->set(pvStructure->getSubField("value")->getFieldOffset());
527  } else {
528  bitSet->set(value->getFieldOffset());
529  }
530  break;
531  }
532  case DBR_STRING: copy_DBRScalar<dbr_string_t,PVString>(value,pvValue); break;
533  case DBR_CHAR:
534  if(dbfIsUCHAR)
535  {
536  copy_DBRScalar<dbr_char_t,PVUByte>(value,pvValue);
537  break;
538  }
539  copy_DBRScalar<dbr_char_t,PVByte>(value,pvValue); break;
540  case DBR_SHORT:
541  if(dbfIsUSHORT)
542  {
543  copy_DBRScalar<dbr_short_t,PVUShort>(value,pvValue);
544  break;
545  }
546  copy_DBRScalar<dbr_short_t,PVShort>(value,pvValue); break;
547  case DBR_LONG:
548  if(dbfIsULONG)
549  {
550  copy_DBRScalar<dbr_long_t,PVUInt>(value,pvValue);
551  break;
552  }
553  copy_DBRScalar<dbr_long_t,PVInt>(value,pvValue); break;
554  case DBR_FLOAT: copy_DBRScalar<dbr_float_t,PVFloat>(value,pvValue); break;
555  case DBR_DOUBLE:
556  if(dbfIsINT64)
557  {
558  copy_DBRScalar<dbr_double_t,PVLong>(value,pvValue);
559  break;
560  }
561  if(dbfIsUINT64)
562  {
563  copy_DBRScalar<dbr_double_t,PVULong>(value,pvValue);
564  break;
565  }
566  copy_DBRScalar<dbr_double_t,PVDouble>(value,pvValue); break;
567  default:
568  Status errorStatus(
569  Status::STATUSTYPE_ERROR, string("DbdToPv::getFromDBD logic error"));
570  return errorStatus;
571  }
572  }
573  if(caValueType!=DBR_ENUM) {
574  bitSet->set(pvStructure->getSubField("value")->getFieldOffset());
575  }
576  }
577  if(alarmRequested) {
578  // Note that status and severity are aways the first two members of DBR_
579  const dbr_sts_string *data = static_cast<const dbr_sts_string *>(args.dbr);
580  dbr_short_t status = data->status;
581  dbr_short_t severity = data->severity;
582  bool statusChanged = false;
583  bool severityChanged = false;
584  PVStructurePtr pvAlarm(pvStructure->getSubField<PVStructure>("alarm"));
585  PVIntPtr pvSeverity(pvAlarm->getSubField<PVInt>("severity"));
586  if(caAlarm.severity!=severity) {
587  caAlarm.severity = severity;
588  pvSeverity->put(severity);
589  severityChanged = true;
590  }
591  PVStringPtr pvMessage(pvAlarm->getSubField<PVString>("message"));
592  PVIntPtr pvStatus(pvAlarm->getSubField<PVInt>("status"));
593  if(caAlarm.status!=status) {
594  caAlarm.status = status;
595  pvStatus->put(convertDBstatus(status));
596  string message("UNKNOWN STATUS");
597  if(status<=ALARM_NSTATUS) message = string(epicsAlarmConditionStrings[status]);
598  pvMessage->put(message);
599  statusChanged = true;
600  }
601  if(statusChanged&&severityChanged) {
602  bitSet->set(pvAlarm->getFieldOffset());
603  } else if(severityChanged) {
604  bitSet->set(pvSeverity->getFieldOffset());
605  } else if(statusChanged) {
606  bitSet->set(pvStatus->getFieldOffset());
607  bitSet->set(pvMessage->getFieldOffset());
608  }
609  }
610  if(timeStampRequested) {
611  // Note that epicsTimeStamp always follows status and severity
612  const dbr_time_string *data = static_cast<const dbr_time_string *>(args.dbr);
613  epicsTimeStamp stamp = data->stamp;
614  PVStructurePtr pvTimeStamp(pvStructure->getSubField<PVStructure>("timeStamp"));
615  if(caTimeStamp.secPastEpoch!=stamp.secPastEpoch) {
616  caTimeStamp.secPastEpoch = stamp.secPastEpoch;
617  PVLongPtr pvSeconds(pvTimeStamp->getSubField<PVLong>("secondsPastEpoch"));
618  pvSeconds->put(stamp.secPastEpoch+posixEpochAtEpicsEpoch);
619  bitSet->set(pvSeconds->getFieldOffset());
620  }
621  if(caTimeStamp.nsec!=stamp.nsec) {
622  caTimeStamp.nsec = stamp.nsec;
623  PVIntPtr pvNano(pvTimeStamp->getSubField<PVInt>("nanoseconds"));
624  pvNano->put(stamp.nsec);
625  bitSet->set(pvNano->getFieldOffset());
626  }
627  }
628  if(controlRequested)
629  {
630  double upper_ctrl_limit = 0.0;
631  double lower_ctrl_limit = 0.0;
632  switch(caRequestType) {
633  case DBR_CTRL_CHAR:
634  get_DBRControl<dbr_ctrl_char>(args.dbr,&upper_ctrl_limit,&lower_ctrl_limit); break;
635  case DBR_CTRL_SHORT:
636  get_DBRControl<dbr_ctrl_short>(args.dbr,&upper_ctrl_limit,&lower_ctrl_limit); break;
637  case DBR_CTRL_LONG:
638  get_DBRControl<dbr_ctrl_long>(args.dbr,&upper_ctrl_limit,&lower_ctrl_limit); break;
639  case DBR_CTRL_FLOAT:
640  get_DBRControl<dbr_ctrl_float>(args.dbr,&upper_ctrl_limit,&lower_ctrl_limit); break;
641  case DBR_CTRL_DOUBLE:
642  get_DBRControl<dbr_ctrl_double>(args.dbr,&upper_ctrl_limit,&lower_ctrl_limit); break;
643  default :
644  throw std::runtime_error("DbdToPv::getFromDBD logic error");
645  }
646  PVStructurePtr pvControl(pvStructure->getSubField<PVStructure>("control"));
647  if(caControl.upper_ctrl_limit!=upper_ctrl_limit) {
648  caControl.upper_ctrl_limit = upper_ctrl_limit;
649  PVDoublePtr pv = pvControl->getSubField<PVDouble>("limitHigh");
650  pv->put(upper_ctrl_limit);
651  bitSet->set(pv->getFieldOffset());
652  }
653  if(caControl.lower_ctrl_limit!=lower_ctrl_limit) {
654  caControl.lower_ctrl_limit = lower_ctrl_limit;
655  PVDoublePtr pv = pvControl->getSubField<PVDouble>("limitLow");
656  pv->put(lower_ctrl_limit);
657  bitSet->set(pv->getFieldOffset());
658  }
659  }
660  if(displayRequested)
661  {
662  string units;
663  string format;
664  double upper_disp_limit = 0.0;
665  double lower_disp_limit = 0.0;
666  switch(caRequestType) {
667  case DBR_CTRL_CHAR:
668  get_DBRDisplay<dbr_ctrl_char>(args.dbr,&upper_disp_limit,&lower_disp_limit,&units);
669  format = "I4"; break;
670  case DBR_CTRL_SHORT:
671  get_DBRDisplay<dbr_ctrl_short>(args.dbr,&upper_disp_limit,&lower_disp_limit,&units);
672  format = "I6"; break;
673  case DBR_CTRL_LONG:
674  get_DBRDisplay<dbr_ctrl_long>(args.dbr,&upper_disp_limit,&lower_disp_limit,&units);
675  format = "I12"; break;
676  case DBR_CTRL_FLOAT:
677  get_DBRDisplay<dbr_ctrl_float>(args.dbr,&upper_disp_limit,&lower_disp_limit,&units);
678  {
679  const dbr_ctrl_float *data = static_cast<const dbr_ctrl_float *>(args.dbr);
680  int prec = data->precision;
681  ostringstream s;
682  s << "F" << prec + 6 << "." << prec;
683  format = s.str();
684  }
685  break;
686  case DBR_CTRL_DOUBLE:
687  get_DBRDisplay<dbr_ctrl_double>(args.dbr,&upper_disp_limit,&lower_disp_limit,&units);
688  {
689  const dbr_ctrl_double *data = static_cast<const dbr_ctrl_double *>(args.dbr);
690  int prec = data->precision;
691  ostringstream s;
692  s << "F" << prec + 6 << "." << prec;
693  format = s.str();
694  }
695  break;
696  default :
697  throw std::runtime_error("DbdToPv::getFromDBD logic error");
698  }
699  PVStructurePtr pvDisplay(pvStructure->getSubField<PVStructure>("display"));
700  if(caDisplay.lower_disp_limit!=lower_disp_limit) {
701  caDisplay.lower_disp_limit = lower_disp_limit;
702  PVDoublePtr pvDouble = pvDisplay->getSubField<PVDouble>("limitLow");
703  pvDouble->put(lower_disp_limit);
704  bitSet->set(pvDouble->getFieldOffset());
705  }
706  if(caDisplay.upper_disp_limit!=upper_disp_limit) {
707  caDisplay.upper_disp_limit = upper_disp_limit;
708  PVDoublePtr pvDouble = pvDisplay->getSubField<PVDouble>("limitHigh");
709  pvDouble->put(upper_disp_limit);
710  bitSet->set(pvDouble->getFieldOffset());
711  }
712  if(caDisplay.units!=units) {
713  caDisplay.units = units;
714  PVStringPtr pvString = pvDisplay->getSubField<PVString>("units");
715  pvString->put(units);
716  bitSet->set(pvString->getFieldOffset());
717  }
718  if(caDisplay.format!=format) {
719  caDisplay.format = format;
720  PVStringPtr pvString = pvDisplay->getSubField<PVString>("format");
721  if(pvString) {
722  pvString->put(format);
723  bitSet->set(pvString->getFieldOffset());
724  }
725  }
726  }
727  if(valueAlarmRequested) {
728  double upper_alarm_limit = 0.0;
729  double upper_warning_limit = 0.0;
730  double lower_warning_limit = 0.0;
731  double lower_alarm_limit = 0.0;
732  switch(caRequestType) {
733  case DBR_CTRL_CHAR:
734  get_DBRValueAlarm<dbr_ctrl_char>(args.dbr,
735  &upper_alarm_limit,&upper_warning_limit,
736  &lower_warning_limit,&lower_alarm_limit);
737  break;
738  case DBR_CTRL_SHORT:
739  get_DBRValueAlarm<dbr_ctrl_short>(args.dbr,
740  &upper_alarm_limit,&upper_warning_limit,
741  &lower_warning_limit,&lower_alarm_limit);
742  break;
743  case DBR_CTRL_LONG:
744  get_DBRValueAlarm<dbr_ctrl_long>(args.dbr,
745  &upper_alarm_limit,&upper_warning_limit,
746  &lower_warning_limit,&lower_alarm_limit);
747  break;
748  case DBR_CTRL_FLOAT:
749  get_DBRValueAlarm<dbr_ctrl_float>(args.dbr,
750  &upper_alarm_limit,&upper_warning_limit,
751  &lower_warning_limit,&lower_alarm_limit);
752  break;
753  case DBR_CTRL_DOUBLE:
754  get_DBRValueAlarm<dbr_ctrl_double>(args.dbr,
755  &upper_alarm_limit,&upper_warning_limit,
756  &lower_warning_limit,&lower_alarm_limit);
757  break;
758  default :
759  throw std::runtime_error("DbdToPv::getFromDBD logic error");
760  }
761  ConvertPtr convert(getConvert());
762  PVStructurePtr pvValueAlarm(pvStructure->getSubField<PVStructure>("valueAlarm"));
763  if(caValueAlarm.upper_alarm_limit!=upper_alarm_limit) {
764  caValueAlarm.upper_alarm_limit = upper_alarm_limit;
765  PVScalarPtr pv = pvValueAlarm->getSubField<PVScalar>("highAlarmLimit");
766  convert->fromDouble(pv,upper_alarm_limit);
767  bitSet->set(pv->getFieldOffset());
768  }
769  if(caValueAlarm.upper_warning_limit!=upper_warning_limit) {
770  caValueAlarm.upper_warning_limit = upper_warning_limit;
771  PVScalarPtr pv = pvValueAlarm->getSubField<PVScalar>("highWarningLimit");
772  convert->fromDouble(pv,upper_warning_limit);
773  bitSet->set(pv->getFieldOffset());
774  }
775  if(caValueAlarm.lower_warning_limit!=lower_warning_limit) {
776  caValueAlarm.lower_warning_limit = lower_warning_limit;
777  PVScalarPtr pv = pvValueAlarm->getSubField<PVScalar>("lowWarningLimit");
778  convert->fromDouble(pv,lower_warning_limit);
779  bitSet->set(pv->getFieldOffset());
780  }
781  if(caValueAlarm.lower_alarm_limit!=lower_alarm_limit) {
782  caValueAlarm.lower_alarm_limit = lower_alarm_limit;
783  PVScalarPtr pv = pvValueAlarm->getSubField<PVScalar>("lowAlarmLimit");
784  convert->fromDouble(pv,lower_alarm_limit);
785  bitSet->set(pv->getFieldOffset());
786  }
787  }
788  if(firstTime) {
789  firstTime = false;
790  bitSet->clear();
791  bitSet->set(0);
792  }
793  return Status::Ok;
794 }
DBR_CHAR
#define DBR_CHAR
Definition: db_access.h:74
DBR_STRING
#define DBR_STRING
Definition: db_access.h:69
epics::pvData::shared_vector::resize
void resize(size_t i)
Grow or shrink array.
Definition: sharedVector.h:457
dbr_sts_string::severity
dbr_short_t severity
Definition: db_access.h:178
value
Definition: link.h:174
epics::pvData::PVScalar
PVScalar is the base class for each scalar field.
Definition: pvData.h:272
epics::pvData::PVIntPtr
std::tr1::shared_ptr< PVInt > PVIntPtr
Definition: pvData.h:507
event_handler_args::dbr
const void * dbr
Definition: cadef.h:89
epics::pvData::shared_vector
A holder for a contiguous piece of memory.
Definition: sharedVector.h:27
dbr_sts_string::status
dbr_short_t status
Definition: db_access.h:177
status
pvd::Status status
Definition: sharedstate_pv.cpp:122
epics::pvData::Status::Ok
static Status Ok
Definition: status.h:47
dbr_ctrl_float
Definition: db_access.h:440
pv
Definition: tool_lib.h:67
DBR_FLOAT
#define DBR_FLOAT
Definition: db_access.h:72
str
#define str(v)
Definition: iocshRegisterCommon.c:26
dbr_sts_string
Definition: db_access.h:176
epics::pvData::PVLongPtr
std::tr1::shared_ptr< PVLong > PVLongPtr
Definition: pvData.h:508
epics::pvData::PVStringArrayPtr
std::tr1::shared_ptr< PVStringArray > PVStringArrayPtr
Definition: pvData.h:1464
epics::pvData::copy
void copy(PVValueArray< T > &pvFrom, size_t fromOffset, size_t fromStride, PVValueArray< T > &pvTo, size_t toOffset, size_t toStride, size_t count)
Copy a subarray from one scalar array to another.
Definition: pvSubArrayCopy.cpp:23
DBR_CTRL_FLOAT
#define DBR_CTRL_FLOAT
Definition: db_access.h:104
epicsTimeStamp::secPastEpoch
epicsUInt32 secPastEpoch
seconds since 0000 Jan 1, 1990
Definition: epicsTime.h:34
dbr_value_ptr
#define dbr_value_ptr(PDBR, DBR_TYPE)
Definition: db_access.h:540
epics::pvData::PVString
PVString is special case, since it implements SerializableArray.
Definition: pvData.h:521
ECA_NORMAL
#define ECA_NORMAL
Definition: caerr.h:77
DBR_CTRL_SHORT
#define DBR_CTRL_SHORT
Definition: db_access.h:102
epics::pvData::PVValueArray
template class for all extensions of PVArray.
Definition: pvData.h:55
DBR_DOUBLE
#define DBR_DOUBLE
Definition: db_access.h:76
DBR_CTRL_CHAR
#define DBR_CTRL_CHAR
Definition: db_access.h:106
DBR_SHORT
#define DBR_SHORT
Definition: db_access.h:71
epics::pvData::PVScalarArray
Base class for a scalarArray.
Definition: pvData.h:618
epics::pvData::PVScalarPtr
std::tr1::shared_ptr< PVScalar > PVScalarPtr
Definition: pvData.h:77
dbr_time_string::stamp
epicsTimeStamp stamp
Definition: db_access.h:245
dbr_string_t
epicsOldString dbr_string_t
Definition: db_access.h:38
dbr_time_string
Definition: db_access.h:242
epics::pvData::PVStructure
Data interface for a structure,.
Definition: pvData.h:712
epics::pvData::PVScalarValue::put
void put(typename storage_t::arg_type v)
Definition: pvData.h:401
dbr_ctrl_double::precision
dbr_short_t precision
Definition: db_access.h:504
epics::pvData::PVStructurePtr
std::tr1::shared_ptr< PVStructure > PVStructurePtr
Definition: pvData.h:87
dbr_ctrl_float::precision
dbr_short_t precision
Definition: db_access.h:443
DBR_ENUM
#define DBR_ENUM
Definition: db_access.h:73
dbr_enum_t
epicsUInt16 dbr_enum_t
Definition: db_access.h:43
epics::pvData::PVStringPtr
std::tr1::shared_ptr< PVString > PVStringPtr
Definition: pvData.h:540
ca_message
const char *epicsStdCall ca_message(long ca_status)
Definition: access.cpp:561
DBR_CTRL_LONG
#define DBR_CTRL_LONG
Definition: db_access.h:107
DBR_LONG
#define DBR_LONG
Definition: db_access.h:75
epics::pvData::PVScalarValue
Class that holds the data for each possible scalar type.
Definition: pvData.h:54
epicsTimeStamp
EPICS time stamp, for use from C code.
Definition: epicsTime.h:33
epics::pvData::ConvertPtr
std::tr1::shared_ptr< Convert > ConvertPtr
Definition: convert.h:23
epics::pvData::posixEpochAtEpicsEpoch
epicsShareExtern const int64 posixEpochAtEpicsEpoch
Definition: timeStamp.h:25
dbr_ctrl_double
Definition: db_access.h:501
dbr_short_t
epicsInt16 dbr_short_t
Definition: db_access.h:40
prec
int prec
Definition: reader.c:29
epics::pvData::PVScalarArrayPtr
std::tr1::shared_ptr< PVScalarArray > PVScalarArrayPtr
Definition: pvData.h:82
epicsAlarmConditionStrings
LIBCOM_API const char * epicsAlarmConditionStrings[ALARM_NSTATUS]
How to convert an alarm condition/status into a string.
Definition: alarmString.c:26
DBR_CTRL_DOUBLE
#define DBR_CTRL_DOUBLE
Definition: db_access.h:108
event_handler_args::count
long count
Definition: cadef.h:88
event_handler_args::status
int status
Definition: cadef.h:90
epics::pvData::PVDoublePtr
std::tr1::shared_ptr< PVDouble > PVDoublePtr
Definition: pvData.h:514
epicsTimeStamp::nsec
epicsUInt32 nsec
nanoseconds within second
Definition: epicsTime.h:35
chtype epics::pvAccess::ca::DbdToPv::getRequestType ( )

Definition at line 320 of file dbdToPv.cpp.

321 {
322  if(caRequestType<0) {
323  throw std::runtime_error("DbDToPv::getRequestType: bad type");
324  }
325  return caRequestType;
326 }
Structure::const_shared_pointer epics::pvAccess::ca::DbdToPv::getStructure ( )

Definition at line 328 of file dbdToPv.cpp.

329 {
330  return structure;
331 }
epics::pvAccess::ca::DbdToPv::POINTER_DEFINITIONS ( DbdToPv  )
Status epics::pvAccess::ca::DbdToPv::putToDBD ( CAChannelPtr const &  caChannel,
epics::pvData::PVStructurePtr const &  pvStructure,
bool  block,
caCallbackFunc  putHandler,
void *  userArg 
)

Definition at line 815 of file dbdToPv.cpp.

821 {
822  chid channelID = caChannel->getChannelID();
823  const void *pValue = NULL;
824  unsigned long count = 1;
825  char *ca_stringBuffer(0);
826  dbr_char_t bvalue(0);
827  dbr_short_t svalue(0);
828  dbr_long_t lvalue(0);
829  dbr_float_t fvalue(0);
830  dbr_double_t dvalue(0);
831  if(isArray) {
832  PVScalarArrayPtr pvValue = pvStructure->getSubField<PVScalarArray>("value");
833  switch(caValueType) {
834  case DBR_STRING:
835  {
836  PVStringArrayPtr pvValue = pvStructure->getSubField<PVStringArray>("value");
837  count = pvValue->getLength();
838  if(count<1) break;
839  if(count>maxElements) count = maxElements;
840  int nbytes = count*MAX_STRING_SIZE;
841  ca_stringBuffer = new char[nbytes];
842  memset(ca_stringBuffer, 0, nbytes);
843  pValue = ca_stringBuffer;
844  PVStringArray::const_svector stringArray(pvValue->view());
845  char *pnext = ca_stringBuffer;
846  for(size_t i=0; i<count; ++i) {
847  string value = stringArray[i];
848  size_t len = value.length();
849  if (len >= MAX_STRING_SIZE) len = MAX_STRING_SIZE - 1;
850  memcpy(pnext, value.c_str(), len);
851  pnext += MAX_STRING_SIZE;
852  }
853  break;
854  }
855  case DBR_CHAR:
856  if(charArrayIsString)
857  {
858  PVStringPtr pvValue(pvStructure->getSubField<PVString>("value"));
859  const char * pchar = pvValue->get().c_str();
860  pValue = pchar;
861  count = pvValue->get().length();
862  break;
863  }
864  if(dbfIsUCHAR)
865  {
866  pValue = put_DBRScalarArray<dbr_char_t,PVUByteArray>(&count,pvValue);
867  break;
868  }
869  pValue = put_DBRScalarArray<dbr_char_t,PVByteArray>(&count,pvValue);
870  break;
871  case DBR_SHORT:
872  if(dbfIsUSHORT)
873  {
874  pValue = put_DBRScalarArray<dbr_short_t,PVUShortArray>(&count,pvValue);
875  break;
876  }
877  pValue = put_DBRScalarArray<dbr_short_t,PVShortArray>(&count,pvValue);
878  break;
879  case DBR_LONG:
880  if(dbfIsULONG)
881  {
882  pValue = put_DBRScalarArray<dbr_long_t,PVUIntArray>(&count,pvValue);
883  break;
884  }
885  pValue = put_DBRScalarArray<dbr_long_t,PVIntArray>(&count,pvValue);
886  break;
887  case DBR_FLOAT:
888  pValue = put_DBRScalarArray<dbr_float_t,PVFloatArray>(&count,pvValue);
889  break;
890  case DBR_DOUBLE:
891  if(dbfIsINT64)
892  {
893  PVLongArrayPtr pvValue(pvStructure->getSubField<PVLongArray>("value"));
894  PVLongArray::const_svector sv(pvValue->view());
895  pvDoubleArray = PVDoubleArrayPtr(getPVDataCreate()->createPVScalarArray<PVDoubleArray>());
896  pvDoubleArray->putFrom(sv);
897  const double * pdouble = pvDoubleArray->view().data();
898  count = pvValue->getLength();
899  pValue = pdouble;
900  break;
901  }
902  if(dbfIsUINT64)
903  {
904  PVULongArrayPtr pvValue(pvStructure->getSubField<PVULongArray>("value"));
905  PVULongArray::const_svector sv(pvValue->view());
906  pvDoubleArray = PVDoubleArrayPtr(getPVDataCreate()->createPVScalarArray<PVDoubleArray>());
907  pvDoubleArray->putFrom(sv);
908  const double * pdouble = pvDoubleArray->view().data();
909  count = pvValue->getLength();
910  pValue = pdouble;
911  break;
912  }
913  pValue = put_DBRScalarArray<dbr_double_t,PVDoubleArray>(&count,pvValue);
914  break;
915  default:
916  Status errorStatus(
917  Status::STATUSTYPE_ERROR, string("DbdToPv::getFromDBD logic error"));
918  return errorStatus;
919  }
920  } else {
921  PVScalarPtr pvValue = pvStructure->getSubField<PVScalar>("value");
922  switch(caValueType) {
923  case DBR_ENUM:
924  {
925  dbr_enum_t indexvalue = pvStructure->getSubField<PVInt>("value.index")->get();
926  pValue = &indexvalue;
927  break;
928  }
929  case DBR_STRING: pValue = pvStructure->getSubField<PVString>("value")->get().c_str(); break;
930  case DBR_CHAR:
931  if(dbfIsUCHAR)
932  {
933  pValue = put_DBRScalar<dbr_char_t,PVUByte>(&bvalue,pvValue);
934  break;
935  }
936  pValue = put_DBRScalar<dbr_char_t,PVByte>(&bvalue,pvValue); break;
937  case DBR_SHORT:
938  if(dbfIsUSHORT)
939  {
940  pValue = put_DBRScalar<dbr_short_t,PVUShort>(&svalue,pvValue);
941  break;
942  }
943  pValue = put_DBRScalar<dbr_short_t,PVShort>(&svalue,pvValue); break;
944  case DBR_LONG:
945  if(dbfIsULONG)
946  {
947  pValue = put_DBRScalar<dbr_long_t,PVUInt>(&lvalue,pvValue);
948  break;
949  }
950  pValue = put_DBRScalar<dbr_long_t,PVInt>(&lvalue,pvValue); break;
951  case DBR_FLOAT: pValue = put_DBRScalar<dbr_float_t,PVFloat>(&fvalue,pvValue); break;
952  case DBR_DOUBLE:
953  if(dbfIsINT64)
954  {
955  pValue = put_DBRScalar<dbr_double_t,PVLong>(&dvalue,pvValue);
956  break;
957  }
958  if(dbfIsUINT64)
959  {
960  pValue = put_DBRScalar<dbr_double_t,PVULong>(&dvalue,pvValue);
961  break;
962  }
963  pValue = put_DBRScalar<dbr_double_t,PVDouble>(&dvalue,pvValue); break;
964  default:
965  Status errorStatus(
966  Status::STATUSTYPE_ERROR, string("DbdToPv::putToDBD logic error"));
967  return errorStatus;
968  }
969  }
970  Status status = Status::Ok;
971  int result = 0;
972  caChannel->attachContext();
973  if(block) {
974  result = ca_array_put_callback(caValueType,count,channelID,pValue,putHandler,userarg);
975  } else {
976  result = ca_array_put(caValueType,count,channelID,pValue);
977  }
978  if(result==ECA_NORMAL) {
979  ca_flush_io();
980  } else {
981  status = Status(Status::STATUSTYPE_ERROR, string(ca_message(result)));
982  }
983  if(ca_stringBuffer!=NULL) delete[] ca_stringBuffer;
984  return status;
985 }
DBR_CHAR
#define DBR_CHAR
Definition: db_access.h:74
DBR_STRING
#define DBR_STRING
Definition: db_access.h:69
value
Definition: link.h:174
epics::pvData::PVScalar
PVScalar is the base class for each scalar field.
Definition: pvData.h:272
result
pvac::PutEvent result
Definition: clientSync.cpp:117
epics::pvData::shared_vector< const T >
status
pvd::Status status
Definition: sharedstate_pv.cpp:122
epics::pvData::Status::Ok
static Status Ok
Definition: status.h:47
i
int i
Definition: scan.c:967
ca_array_put_callback
LIBCA_API int epicsStdCall ca_array_put_callback(chtype type, unsigned long count, chid chanId, const void *pValue, caEventCallBackFunc *pFunc, void *pArg)
Definition: oldChannelNotify.cpp:412
dbr_float_t
epicsFloat32 dbr_float_t
Definition: db_access.h:46
DBR_FLOAT
#define DBR_FLOAT
Definition: db_access.h:72
NULL
#define NULL
Definition: catime.c:38
epics::pvData::PVStringArrayPtr
std::tr1::shared_ptr< PVStringArray > PVStringArrayPtr
Definition: pvData.h:1464
epics::pvData::PVString
PVString is special case, since it implements SerializableArray.
Definition: pvData.h:521
ECA_NORMAL
#define ECA_NORMAL
Definition: caerr.h:77
ca_array_put
LIBCA_API int epicsStdCall ca_array_put(chtype type, unsigned long count, chid chanId, const void *pValue)
Definition: oldChannelNotify.cpp:476
epics::pvData::PVValueArray
template class for all extensions of PVArray.
Definition: pvData.h:55
ca_flush_io
int epicsStdCall ca_flush_io()
Definition: access.cpp:509
DBR_DOUBLE
#define DBR_DOUBLE
Definition: db_access.h:76
DBR_SHORT
#define DBR_SHORT
Definition: db_access.h:71
epics::pvData::PVScalarArray
Base class for a scalarArray.
Definition: pvData.h:618
epics::pvData::PVScalarPtr
std::tr1::shared_ptr< PVScalar > PVScalarPtr
Definition: pvData.h:77
dbr_double_t
epicsFloat64 dbr_double_t
Definition: db_access.h:47
epics::pvData::PVULongArrayPtr
std::tr1::shared_ptr< PVULongArray > PVULongArrayPtr
Definition: pvData.h:1455
epics::pvData::PVLongArrayPtr
std::tr1::shared_ptr< PVLongArray > PVLongArrayPtr
Definition: pvData.h:1443
dbr_char_t
epicsUInt8 dbr_char_t
Definition: db_access.h:39
DBR_ENUM
#define DBR_ENUM
Definition: db_access.h:73
dbr_enum_t
epicsUInt16 dbr_enum_t
Definition: db_access.h:43
epics::pvData::PVStringPtr
std::tr1::shared_ptr< PVString > PVStringPtr
Definition: pvData.h:540
ca_message
const char *epicsStdCall ca_message(long ca_status)
Definition: access.cpp:561
DBR_LONG
#define DBR_LONG
Definition: db_access.h:75
epics::pvData::PVScalarValue
Class that holds the data for each possible scalar type.
Definition: pvData.h:54
MAX_STRING_SIZE
#define MAX_STRING_SIZE
Definition: epicsTypes.h:65
epics::pvData::PVValueArray::getLength
virtual size_t getLength() const OVERRIDE FINAL
Definition: pvData.h:1203
dbr_short_t
epicsInt16 dbr_short_t
Definition: db_access.h:40
dbr_long_t
epicsInt32 dbr_long_t
Definition: db_access.h:44
epics::pvData::PVScalarArrayPtr
std::tr1::shared_ptr< PVScalarArray > PVScalarArrayPtr
Definition: pvData.h:82
epics::pvData::PVDoubleArrayPtr
std::tr1::shared_ptr< PVDoubleArray > PVDoubleArrayPtr
Definition: pvData.h:1461
epics::pvData::getPVDataCreate
FORCE_INLINE const PVDataCreatePtr & getPVDataCreate()
Definition: pvData.h:1648
The documentation for this class was generated from the following files: