1833 lines
52 KiB
C++
1833 lines
52 KiB
C++
///
|
|
/// \file PVHolder.h
|
|
/// \author Jan Chrin, PSI
|
|
/// \date Release: February 2015
|
|
/// \version CAFE 1.0.0
|
|
///
|
|
|
|
#ifndef PVHOLDER_H
|
|
#define PVHOLDER_H
|
|
|
|
#include <stdexcept>
|
|
#include <cstring>
|
|
#include <limits>
|
|
#include <cafeConvert.h>
|
|
#include <statusCodes.h>
|
|
#include <helper.h>
|
|
#include <defines.h>
|
|
#include <cafeDataTypeHelper.h>
|
|
#include <boost/smart_ptr/shared_ptr.hpp>
|
|
//include <boost/smart_ptr/make_unique.hpp> boost 1.57
|
|
//include <boost/interprocess/smart_ptr/unique_ptr.hpp>
|
|
#include <vector>
|
|
|
|
|
|
/**
|
|
* \class PVHolder
|
|
* \brief The base class from which the PVDataHolder and PVCtrlHolder
|
|
* classes are derived
|
|
*/
|
|
class PVHolder {
|
|
|
|
protected:
|
|
char pv [PVNAME_SIZE];
|
|
char pvAlias[PVNAME_SIZE];
|
|
char device [PVNAME_SIZE];
|
|
char attrib [PVNAME_SIZE];
|
|
|
|
CAFE_DATATYPE dataTypeNative; //enum
|
|
CAFE_DATATYPE dataType; //enum
|
|
CAFEDataTypeCode cafeDataTypeCode; //class enum<->string mapping
|
|
CAFEStatusCode cafeStatusCode;
|
|
|
|
chtype dbrDataType; //dbrTypeRequest_DataBuffer;
|
|
|
|
unsigned int size;
|
|
unsigned int nelem;
|
|
//unsigned int nelemNative;
|
|
short alarmStatus; //alarm.h 0-22 0=NO_ALARM
|
|
short alarmSeverity; //alarm.h 0=NO_ALARM 1=MINOR 2=MAJOR 3=INVALID
|
|
|
|
CAFEGlobalAlarmCondition acond;
|
|
CAFEGlobalAlarmSeverity aseve;
|
|
|
|
unsigned int userNo; //e.g. add handle
|
|
|
|
unsigned long long beamEventNo;
|
|
//rule is used for synchronous groups only
|
|
bool rule; // to set/get or not to set/get channel; default: true (i.e. set)
|
|
bool hasAlarm;
|
|
int status;
|
|
|
|
short noStr; // for enum
|
|
char strs [MAX_ENUM_STATES][MAX_ENUM_STRING_SIZE];
|
|
|
|
CAFEConvert<double> renderDouble;
|
|
CAFEConvert<float> renderFloat;
|
|
CAFEConvert<short> renderShort;
|
|
CAFEConvert<int> renderLong;
|
|
CAFEConvert<unsigned short> renderEnum;
|
|
CAFEConvert<unsigned char> renderUChar;
|
|
CAFEConvert<dbr_string_t> renderString;
|
|
|
|
CAFEConvert<char> renderChar;
|
|
CAFEConvert<unsigned int> renderULong;
|
|
CAFEConvert<long long> renderLongLong;
|
|
CAFEConvert<unsigned long long> renderULongLong;
|
|
|
|
CAFEConvert<int> renderInt;
|
|
CAFEConvert<unsigned int> renderUInt;
|
|
|
|
|
|
void verifyIndex(unsigned int idx)
|
|
{
|
|
if(idx >= size) {
|
|
std::ostringstream oss;
|
|
oss << "Exception! Index " << idx
|
|
<< " to PVHolder method is out of range. Valid range is from 0 to " << size-1;
|
|
throw std::out_of_range(oss.str());
|
|
}
|
|
};
|
|
|
|
bool isIndexOutOfRange (unsigned int idx)
|
|
{
|
|
return (idx >= size) ? true:false;
|
|
};
|
|
|
|
|
|
public:
|
|
|
|
typedef boost::shared_ptr<CAFE_DATATYPE_UNION []> ValPtr;
|
|
|
|
ValPtr val;
|
|
|
|
boost::shared_ptr<std::vector<double> > ValVD_ptr;
|
|
boost::shared_ptr<std::vector<float> > ValVF_ptr;
|
|
boost::shared_ptr<std::vector<short> > ValVS_ptr;
|
|
boost::shared_ptr<std::vector<int> > ValVI_ptr;
|
|
boost::shared_ptr<std::vector<long> > ValVL_ptr;
|
|
boost::shared_ptr<std::vector<unsigned long> > ValVUL_ptr;
|
|
boost::shared_ptr<std::vector<long long> > ValVLL_ptr;
|
|
boost::shared_ptr<std::vector<unsigned long long> > ValVULL_ptr;
|
|
boost::shared_ptr<std::vector<unsigned char> > ValVC_ptr;
|
|
boost::shared_ptr<std::vector<unsigned short> > ValVUS_ptr;
|
|
boost::shared_ptr<std::vector<std::string> > ValVStr_ptr;
|
|
|
|
typedef boost::shared_ptr<double []> ValDPtr;
|
|
typedef boost::shared_ptr<float []> ValFPtr;
|
|
typedef boost::shared_ptr<short []> ValSPtr;
|
|
typedef boost::shared_ptr<int []> ValIPtr;
|
|
typedef boost::shared_ptr<unsigned char []> ValChPtr;
|
|
typedef boost::shared_ptr<unsigned short []> ValUSPtr;
|
|
typedef boost::shared_ptr<dbr_string_t []> ValStrPtr;
|
|
|
|
ValDPtr ValD_ptr;
|
|
ValFPtr ValF_ptr;
|
|
ValSPtr ValS_ptr;
|
|
ValIPtr ValI_ptr;
|
|
ValChPtr ValCh_ptr;
|
|
ValUSPtr ValUS_ptr;
|
|
ValStrPtr ValStr_ptr;
|
|
|
|
void setUserNo(unsigned int un)
|
|
{
|
|
userNo=un;
|
|
return;
|
|
}
|
|
|
|
unsigned int getUserNo()
|
|
{
|
|
return userNo;
|
|
}
|
|
|
|
|
|
void setRule(bool r)
|
|
{
|
|
rule=r;
|
|
return;
|
|
};
|
|
|
|
void setBeamEventNo (unsigned long long b)
|
|
{
|
|
beamEventNo=b;
|
|
}
|
|
void setPulseID (unsigned long long b)
|
|
{
|
|
beamEventNo=b;
|
|
}
|
|
void setStatus (int st)
|
|
{
|
|
status=st; //for bsread
|
|
}
|
|
void setAlarmStatus (int ast)
|
|
{
|
|
alarmStatus=ast; //for bsread
|
|
}
|
|
void setAlarmSeverity(int asev)
|
|
{
|
|
alarmSeverity=asev; //for bsread
|
|
}
|
|
|
|
const char * getPV() const
|
|
{
|
|
return pv;
|
|
};
|
|
const char * getPVName() const
|
|
{
|
|
return pv;
|
|
};
|
|
const char * getPVAlias() const
|
|
{
|
|
return pvAlias;
|
|
};
|
|
const char * getDevice() const
|
|
{
|
|
return device;
|
|
};
|
|
const char * getAttribute() const
|
|
{
|
|
return attrib;
|
|
};
|
|
unsigned int getNelem() const
|
|
{
|
|
return nelem;
|
|
};
|
|
//unsigned int getNelemNative() const {return nelemNative;};
|
|
const unsigned int getSize() const
|
|
{
|
|
return size;
|
|
};
|
|
CAFE_DATATYPE_UNION_SEQ getVal() const
|
|
{
|
|
return val.get();
|
|
};
|
|
|
|
|
|
short getAlarmStatus() const
|
|
{
|
|
return alarmStatus;
|
|
};
|
|
short getAlarmSeverity() const
|
|
{
|
|
return alarmSeverity;
|
|
};
|
|
|
|
std::string getAlarmStatusAsString()
|
|
{
|
|
return acond.asString(alarmStatus);
|
|
};
|
|
std::string getAlarmSeverityAsString()
|
|
{
|
|
return aseve.asString(alarmSeverity);
|
|
};
|
|
|
|
unsigned long long getBeamEventNo() const
|
|
{
|
|
return beamEventNo;
|
|
};
|
|
unsigned long long getPulseID() const
|
|
{
|
|
return beamEventNo;
|
|
};
|
|
bool getRule() const
|
|
{
|
|
return rule;
|
|
};
|
|
bool getHasAlarm() const
|
|
{
|
|
return hasAlarm;
|
|
};
|
|
int getStatus() const
|
|
{
|
|
return status;
|
|
};
|
|
std::string getStatusAsString()
|
|
{
|
|
return cafeStatusCode.msgIDAsString(status);
|
|
};
|
|
CAFE_DATATYPE getDataTypeClient() const
|
|
{
|
|
return dataType;
|
|
};
|
|
CAFE_DATATYPE getDataType() const
|
|
{
|
|
return dataType;
|
|
};
|
|
|
|
CAFEStatusCode getStatusCode() const
|
|
{
|
|
return cafeStatusCode;
|
|
};
|
|
|
|
short getNoEnumStrings () const
|
|
{
|
|
return noStr;
|
|
};
|
|
char * getEnumString(short indx) const
|
|
{
|
|
return (char *) strs[indx];
|
|
}
|
|
|
|
void setDataType(CAFE_DATATYPE cdt)
|
|
{
|
|
if (cdt > CAFE_DOUBLE || cdt < CAFE_STRING) {
|
|
std::cout << "WARNING: INPUT VALUE NOT A VALID CAFE DATATYPE " << std::endl;
|
|
return;
|
|
}
|
|
else {
|
|
dataType=cdt;
|
|
return;
|
|
}
|
|
};
|
|
|
|
void set(double d)
|
|
{
|
|
val[0].d=d;
|
|
dataType=CAFE_DOUBLE;
|
|
};
|
|
void set(float f)
|
|
{
|
|
val[0].f=f;
|
|
dataType=CAFE_FLOAT;
|
|
};
|
|
void set(short s)
|
|
{
|
|
val[0].s=s;
|
|
dataType=CAFE_SHORT;
|
|
};
|
|
void set(long long l)
|
|
{
|
|
if (l > std::numeric_limits<dbr_long_t>::max()) {
|
|
std::cout << "WARNING: INPUT VALUE GREATER THAN MAX LIMIT OF dbr_long_t " << std::endl;
|
|
std::cout << "TYPE CASTING TO DOUBLE! " << std::endl;
|
|
val[0].d= (double) l;
|
|
dataType=CAFE_DOUBLE;
|
|
}
|
|
else {
|
|
val[0].l= (int) l;
|
|
dataType=CAFE_LONG;
|
|
};
|
|
}
|
|
void set(int l)
|
|
{
|
|
val[0].l=l;
|
|
dataType=CAFE_LONG;
|
|
};
|
|
void set(unsigned long long l)
|
|
{
|
|
if (l > (unsigned long long) std::numeric_limits<dbr_long_t>::max()) {
|
|
std::cout << "WARNING: INPUT VALUE GREATER THAN MAX LIMIT OF dbr_long_t " << std::endl;
|
|
std::cout << "TYPE CASTING TO DOUBLE! " << std::endl;
|
|
val[0].d= (double) l;
|
|
dataType=CAFE_DOUBLE;
|
|
}
|
|
else {
|
|
val[0].l= (int) l;
|
|
dataType=CAFE_LONG;
|
|
};
|
|
}
|
|
|
|
//For Cython
|
|
void setString(std::string str)
|
|
{
|
|
strcpy(val[0].str,str.c_str());
|
|
dataType=CAFE_STRING;
|
|
};
|
|
void setDouble(double d)
|
|
{
|
|
val[0].d=d;
|
|
dataType=CAFE_DOUBLE;
|
|
};
|
|
void setInt(int l)
|
|
{
|
|
val[0].l=l;
|
|
dataType=CAFE_LONG;
|
|
};
|
|
|
|
|
|
void setVString(std::vector<std::string> Vstr)
|
|
{
|
|
if(Vstr.size()!=nelem) {
|
|
nelem=Vstr.size();
|
|
}
|
|
for (unsigned int i=0; i<nelem; ++ i) {
|
|
strcpy(val[i].str,Vstr[i].c_str());
|
|
}
|
|
dataType=CAFE_STRING;
|
|
};
|
|
void setVDouble(std::vector<double> Vd)
|
|
{
|
|
if(Vd.size()!=nelem) {
|
|
nelem=Vd.size();
|
|
}
|
|
for (unsigned int i=0; i<nelem; ++ i) {
|
|
val[i].d=Vd[i];
|
|
}
|
|
dataType=CAFE_DOUBLE;
|
|
};
|
|
void setVInt (std::vector<int> Vl)
|
|
{
|
|
if(Vl.size()!=nelem) {
|
|
nelem=Vl.size();
|
|
}
|
|
for (unsigned int i=0; i<nelem; ++ i) {
|
|
val[i].l=Vl[i];
|
|
}
|
|
dataType=CAFE_LONG;
|
|
};
|
|
|
|
|
|
|
|
|
|
void set(std::vector<std::string> Vstr)
|
|
{
|
|
if(Vstr.size()!=nelem) {
|
|
nelem=Vstr.size();
|
|
}
|
|
for (unsigned int i=0; i<nelem; ++ i) {
|
|
strcpy(val[i].str,Vstr[i].c_str());
|
|
}
|
|
dataType=CAFE_STRING;
|
|
};
|
|
void set(std::vector<double> Vd)
|
|
{
|
|
if(Vd.size()!=nelem) {
|
|
nelem=Vd.size();
|
|
}
|
|
for (unsigned int i=0; i<nelem; ++ i) {
|
|
val[i].d=Vd[i];
|
|
}
|
|
dataType=CAFE_DOUBLE;
|
|
};
|
|
void set(std::vector<float> Vf)
|
|
{
|
|
if(Vf.size()!=nelem) {
|
|
nelem=Vf.size();
|
|
}
|
|
for (unsigned int i=0; i<nelem; ++ i) {
|
|
val[i].f=Vf[i];
|
|
}
|
|
dataType=CAFE_FLOAT;
|
|
};
|
|
|
|
void set (std::vector<int> Vl)
|
|
{
|
|
if(Vl.size()!=nelem) {
|
|
nelem=Vl.size();
|
|
}
|
|
for (unsigned int i=0; i<nelem; ++ i) {
|
|
val[i].l=Vl[i];
|
|
}
|
|
dataType=CAFE_LONG;
|
|
};
|
|
|
|
void set (std::vector<long> Vl)
|
|
{
|
|
if(Vl.size()!=nelem) {
|
|
nelem=Vl.size();
|
|
}
|
|
for (unsigned int i=0; i<nelem; ++ i) {
|
|
val[i].l=Vl[i];
|
|
}
|
|
dataType=CAFE_LONG;
|
|
};
|
|
|
|
void set (std::vector<unsigned long> Vul)
|
|
{
|
|
if(Vul.size()!=nelem) {
|
|
nelem=Vul.size();
|
|
}
|
|
for (unsigned int i=0; i<nelem; ++ i) {
|
|
val[i].d=Vul[i];
|
|
}
|
|
dataType=CAFE_DOUBLE;
|
|
};
|
|
|
|
void set (std::vector<long long> Vll)
|
|
{
|
|
if(Vll.size()!=nelem) {
|
|
nelem=Vll.size();
|
|
}
|
|
for (unsigned int i=0; i<nelem; ++ i) {
|
|
val[i].d=Vll[i];
|
|
}
|
|
dataType=CAFE_DOUBLE;
|
|
};
|
|
|
|
void set (std::vector<unsigned long long> Vull)
|
|
{
|
|
if(Vull.size()!=nelem) {
|
|
nelem=Vull.size();
|
|
}
|
|
for (unsigned int i=0; i<nelem; ++ i) {
|
|
val[i].d=Vull[i];
|
|
}
|
|
dataType=CAFE_DOUBLE;
|
|
};
|
|
|
|
void set (std::vector<short> Vs)
|
|
{
|
|
if(Vs.size()!=nelem) {
|
|
nelem=Vs.size();
|
|
}
|
|
for (unsigned int i=0; i<nelem; ++ i) {
|
|
val[i].s=Vs[i];
|
|
}
|
|
dataType=CAFE_SHORT;
|
|
};
|
|
|
|
void set (std::vector<unsigned short> Vus)
|
|
{
|
|
if(Vus.size()!=nelem) {
|
|
nelem=Vus.size();
|
|
}
|
|
for (unsigned int i=0; i<nelem; ++ i) {
|
|
val[i].us=Vus[i];
|
|
}
|
|
dataType=CAFE_ENUM;
|
|
};
|
|
|
|
void set (std::vector<unsigned char> Vc)
|
|
{
|
|
if(Vc.size()!=nelem) {
|
|
nelem=Vc.size();
|
|
}
|
|
for (unsigned int i=0; i<nelem; ++ i) {
|
|
val[i].ch=Vc[i];
|
|
}
|
|
dataType=CAFE_CHAR;
|
|
};
|
|
|
|
|
|
|
|
void set(unsigned int l)
|
|
{
|
|
val[0].l= (int) l;
|
|
dataType=CAFE_LONG;
|
|
};
|
|
void set(unsigned short us)
|
|
{
|
|
val[0].us=us;
|
|
dataType=CAFE_ENUM;
|
|
};
|
|
void set(unsigned char ch)
|
|
{
|
|
val[0].ch=ch;
|
|
dataType=CAFE_CHAR;
|
|
};
|
|
void set(dbr_string_t str)
|
|
{
|
|
strcpy(val[0].str,str);
|
|
dataType=CAFE_STRING;
|
|
};
|
|
void set(std::string str)
|
|
{
|
|
strcpy(val[0].str,str.c_str());
|
|
dataType=CAFE_STRING;
|
|
};
|
|
|
|
|
|
void set(double * d)
|
|
{
|
|
for (unsigned int i=0; i<nelem; ++ i) {
|
|
val[i].d=d[i];
|
|
}
|
|
dataType=CAFE_DOUBLE;
|
|
};
|
|
void set(float * f)
|
|
{
|
|
for (unsigned int i=0; i<nelem; ++ i) {
|
|
val[i].f=f[i];
|
|
}
|
|
dataType=CAFE_FLOAT;
|
|
};
|
|
void set(short * s)
|
|
{
|
|
for (unsigned int i=0; i<nelem; ++ i) {
|
|
val[i].s=s[i];
|
|
}
|
|
dataType=CAFE_SHORT;
|
|
};
|
|
//Examine this!
|
|
void set(long long * ll)
|
|
{
|
|
if ( nelem==1) {
|
|
set((long long) ll[0]);
|
|
}
|
|
else {
|
|
for (unsigned int i=0; i<nelem; ++ i) {
|
|
val[i].d= ll[i];
|
|
}
|
|
dataType=CAFE_DOUBLE;
|
|
}
|
|
};
|
|
void set(unsigned long long * ll)
|
|
{
|
|
if ( nelem==1) {
|
|
set((unsigned long long) ll[0]);
|
|
}
|
|
else {
|
|
for (unsigned int i=0; i<nelem; ++ i) {
|
|
val[i].d= ll[i];
|
|
}
|
|
dataType=CAFE_DOUBLE;
|
|
}
|
|
};
|
|
|
|
void set(int * l)
|
|
{
|
|
for (unsigned int i=0; i<nelem; ++ i) {
|
|
val[i].l=l[i];
|
|
}
|
|
dataType=CAFE_LONG;
|
|
};
|
|
void set(unsigned int * l)
|
|
{
|
|
for (unsigned int i=0; i<nelem; ++ i) {
|
|
val[i].l= (int) l[i];
|
|
}
|
|
dataType=CAFE_LONG;
|
|
};
|
|
void set(unsigned short * us)
|
|
{
|
|
for (unsigned int i=0; i<nelem; ++ i) {
|
|
val[i].us=us[i];
|
|
}
|
|
dataType=CAFE_ENUM;
|
|
};
|
|
void set(unsigned char * ch)
|
|
{
|
|
for (unsigned int i=0; i<nelem; ++ i) {
|
|
val[i].ch=ch[i];
|
|
}
|
|
dataType=CAFE_CHAR;
|
|
};
|
|
void set(dbr_string_t * str)
|
|
{
|
|
for (unsigned int i=0; i<nelem; ++ i) {
|
|
strcpy(val[i].str,str[i]);
|
|
}
|
|
dataType=CAFE_STRING;
|
|
};
|
|
void set(std::string * str)
|
|
{
|
|
for (unsigned int i=0; i<nelem; ++ i) {
|
|
strcpy(val[i].str,str[i].c_str());
|
|
}
|
|
dataType=CAFE_STRING;
|
|
};
|
|
|
|
std::string concatToString()
|
|
{
|
|
std::string psWF = "";
|
|
if (dataTypeNative==CAFE_CHAR) {
|
|
for (unsigned int i=0; i<nelem; ++i) {
|
|
if (val[i].ch != '\0') {
|
|
psWF.append(1, (dbr_char_t) val[i].ch);
|
|
}
|
|
}
|
|
}
|
|
return psWF;
|
|
}
|
|
|
|
std::string getWFAsString()
|
|
{
|
|
std::string psWF = "";
|
|
if (dataTypeNative==CAFE_CHAR) {
|
|
for (unsigned int i=0; i<nelem; ++i) {
|
|
if (val[i].ch != '\0') {
|
|
psWF.append(1, (dbr_char_t) val[i].ch);
|
|
}
|
|
}
|
|
}
|
|
return psWF;
|
|
}
|
|
|
|
|
|
double getDouble(unsigned int idx)
|
|
{
|
|
return (double) val[idx].d;
|
|
}
|
|
float getFloat (unsigned int idx)
|
|
{
|
|
return (float) val[idx].f;
|
|
}
|
|
short getShort (unsigned int idx)
|
|
{
|
|
return (short) val[idx].s;
|
|
}
|
|
int getInt (unsigned int idx)
|
|
{
|
|
return (int) val[idx].l;
|
|
}
|
|
int getLong (unsigned int idx)
|
|
{
|
|
return (int) val[idx].l;
|
|
}
|
|
unsigned short getEnum (unsigned int idx)
|
|
{
|
|
return (unsigned short) val[idx].us;
|
|
}
|
|
unsigned short getUShort(unsigned int idx)
|
|
{
|
|
return (unsigned short) val[idx].us;
|
|
}
|
|
unsigned char getChar (unsigned int idx)
|
|
{
|
|
return (unsigned char ) val[idx].ch;
|
|
}
|
|
|
|
|
|
|
|
dbr_string_t * getString(unsigned int idx)
|
|
{
|
|
#define __METHOD__ "PVHolder::getString "
|
|
if (dataType!=CAFE_STRING) {
|
|
std::cout << "******* WARNING *******" << std::endl;
|
|
std::cout << __METHOD__ << __LINE__ << std::endl;
|
|
std::cout << "DataType is " << (cafeDataTypeCode.message((CAFE_DATATYPE)dataType)).c_str() <<
|
|
" hence getString method is invalid! " << std::endl;
|
|
std::cout << "Use getAsString method if you wish to retrieve the data as a string! " << std::endl;
|
|
std::cout << "**********************" << std::endl;
|
|
//strcpy(val[idx].str, "");
|
|
return (dbr_string_t *) "";
|
|
}
|
|
return (dbr_string_t *) val[idx].str;
|
|
#undef __METHOD__
|
|
}
|
|
|
|
boost::shared_ptr<std::vector<double> > getAsVDouble()
|
|
{
|
|
#define __METHOD__ "PVHolder::getAsVDouble "
|
|
|
|
ValVD_ptr.reset(new std::vector<double>());
|
|
ValVD_ptr->reserve(nelem);
|
|
|
|
switch (dataType) {
|
|
case CAFE_DOUBLE:
|
|
for (unsigned i=0; i<nelem; ++i) {
|
|
ValVD_ptr->push_back(val[i].d);
|
|
}
|
|
break;
|
|
case CAFE_FLOAT:
|
|
for (unsigned i=0; i<nelem; ++i) {
|
|
ValVD_ptr->push_back(val[i].f);
|
|
}
|
|
break;
|
|
case CAFE_LONG:
|
|
for (unsigned i=0; i<nelem; ++i) {
|
|
ValVD_ptr->push_back(val[i].l);
|
|
}
|
|
break;
|
|
case CAFE_SHORT:
|
|
for (unsigned i=0; i<nelem; ++i) {
|
|
ValVD_ptr->push_back(val[i].s);
|
|
}
|
|
break;
|
|
case CAFE_ENUM:
|
|
for (unsigned i=0; i<nelem; ++i) {
|
|
ValVD_ptr->push_back(val[i].us);
|
|
}
|
|
break;
|
|
case CAFE_CHAR:
|
|
for (unsigned i=0; i<nelem; ++i) {
|
|
ValVD_ptr->push_back(val[i].ch);
|
|
}
|
|
break;
|
|
case CAFE_STRING:
|
|
default:
|
|
for (unsigned i=0; i<nelem; ++i) {
|
|
ValVD_ptr->push_back( getAsDouble(i));
|
|
}
|
|
break;
|
|
}
|
|
|
|
return ValVD_ptr;
|
|
#undef __METHOD__
|
|
}
|
|
|
|
boost::shared_ptr<std::vector<float> > getAsVFloat()
|
|
{
|
|
#define __METHOD__ "PVHolder::getAsVFloat "
|
|
|
|
ValVF_ptr.reset(new std::vector<float>());
|
|
ValVF_ptr->reserve(nelem);
|
|
|
|
switch (dataType) {
|
|
case CAFE_DOUBLE:
|
|
for (unsigned i=0; i<nelem; ++i) {
|
|
ValVF_ptr->push_back((float) val[i].d);
|
|
}
|
|
break;
|
|
case CAFE_FLOAT:
|
|
for (unsigned i=0; i<nelem; ++i) {
|
|
ValVF_ptr->push_back(val[i].f);
|
|
}
|
|
break;
|
|
case CAFE_LONG:
|
|
for (unsigned i=0; i<nelem; ++i) {
|
|
ValVF_ptr->push_back(val[i].l);
|
|
}
|
|
break;
|
|
case CAFE_SHORT:
|
|
for (unsigned i=0; i<nelem; ++i) {
|
|
ValVF_ptr->push_back(val[i].s);
|
|
}
|
|
break;
|
|
case CAFE_ENUM:
|
|
for (unsigned i=0; i<nelem; ++i) {
|
|
ValVF_ptr->push_back(val[i].us);
|
|
}
|
|
break;
|
|
case CAFE_CHAR:
|
|
for (unsigned i=0; i<nelem; ++i) {
|
|
ValVF_ptr->push_back(val[i].ch);
|
|
}
|
|
break;
|
|
case CAFE_STRING:
|
|
default:
|
|
for (unsigned i=0; i<nelem; ++i) {
|
|
ValVD_ptr->push_back( getAsFloat(i));
|
|
}
|
|
break;
|
|
}
|
|
|
|
//How to index shared pointer for <std::vector<float> >
|
|
//std::vector<float> * vf= ValVF_ptr.get();
|
|
//std::cout << "size/// " << vf[0].size() << std::endl;
|
|
//std::cout << vf[0][0] << " val " << val[0].f << std::endl;
|
|
//std::cout << vf[0][1] << " val " << val[1].f << std::endl;
|
|
//std::vector<float> vf= *ValVF_ptr.get();
|
|
//std::cout << "size/// " << vf.size() << std::endl;
|
|
//std::cout << vf[0] << " val " << val[0].f << std::endl;
|
|
//std::cout << vf[1] << " val " << val[1].f << std::endl;
|
|
|
|
return ValVF_ptr;
|
|
#undef __METHOD__
|
|
}
|
|
|
|
|
|
boost::shared_ptr<std::vector<int> > getAsVInt()
|
|
{
|
|
#define __METHOD__ "PVHolder::getAsVInt "
|
|
|
|
ValVI_ptr.reset(new std::vector<int>());
|
|
ValVI_ptr->reserve(nelem);
|
|
|
|
switch (dataType) {
|
|
case CAFE_DOUBLE:
|
|
for (unsigned i=0; i<nelem; ++i) {
|
|
ValVI_ptr->push_back((int) val[i].d);
|
|
}
|
|
break;
|
|
case CAFE_FLOAT:
|
|
for (unsigned i=0; i<nelem; ++i) {
|
|
ValVI_ptr->push_back((int) val[i].f);
|
|
}
|
|
break;
|
|
case CAFE_LONG:
|
|
for (unsigned i=0; i<nelem; ++i) {
|
|
ValVI_ptr->push_back(val[i].l);
|
|
}
|
|
break;
|
|
case CAFE_SHORT:
|
|
for (unsigned i=0; i<nelem; ++i) {
|
|
ValVI_ptr->push_back(val[i].s);
|
|
}
|
|
break;
|
|
case CAFE_ENUM:
|
|
for (unsigned i=0; i<nelem; ++i) {
|
|
ValVI_ptr->push_back(val[i].us);
|
|
}
|
|
break;
|
|
case CAFE_CHAR:
|
|
for (unsigned i=0; i<nelem; ++i) {
|
|
ValVI_ptr->push_back(val[i].ch);
|
|
}
|
|
break;
|
|
case CAFE_STRING:
|
|
default:
|
|
for (unsigned i=0; i<nelem; ++i) {
|
|
ValVI_ptr->push_back( getAsInt(i));
|
|
}
|
|
break;
|
|
}
|
|
|
|
return ValVI_ptr;
|
|
#undef __METHOD__
|
|
}
|
|
|
|
|
|
|
|
boost::shared_ptr<std::vector<long> > getAsVLong()
|
|
{
|
|
#define __METHOD__ "PVHolder::getAsVInt "
|
|
|
|
ValVL_ptr.reset(new std::vector<long>());
|
|
ValVL_ptr->reserve(nelem);
|
|
|
|
switch (dataType) {
|
|
case CAFE_DOUBLE:
|
|
for (unsigned i=0; i<nelem; ++i) {
|
|
ValVL_ptr->push_back((long) val[i].d);
|
|
}
|
|
break;
|
|
case CAFE_FLOAT:
|
|
for (unsigned i=0; i<nelem; ++i) {
|
|
ValVL_ptr->push_back((long) val[i].f);
|
|
}
|
|
break;
|
|
case CAFE_LONG:
|
|
for (unsigned i=0; i<nelem; ++i) {
|
|
ValVL_ptr->push_back((long) val[i].l);
|
|
}
|
|
break;
|
|
case CAFE_SHORT:
|
|
for (unsigned i=0; i<nelem; ++i) {
|
|
ValVL_ptr->push_back((long) val[i].s);
|
|
}
|
|
break;
|
|
case CAFE_ENUM:
|
|
for (unsigned i=0; i<nelem; ++i) {
|
|
ValVL_ptr->push_back((long) val[i].us);
|
|
}
|
|
break;
|
|
case CAFE_CHAR:
|
|
for (unsigned i=0; i<nelem; ++i) {
|
|
ValVL_ptr->push_back((long) val[i].ch);
|
|
}
|
|
break;
|
|
case CAFE_STRING:
|
|
default:
|
|
for (unsigned i=0; i<nelem; ++i) {
|
|
ValVL_ptr->push_back( getAsLong(i));
|
|
}
|
|
break;
|
|
}
|
|
|
|
return ValVL_ptr;
|
|
#undef __METHOD__
|
|
}
|
|
|
|
|
|
boost::shared_ptr<std::vector<unsigned long> > getAsVULong()
|
|
{
|
|
#define __METHOD__ "PVHolder::getAsVInt "
|
|
|
|
ValVUL_ptr.reset(new std::vector<unsigned long>());
|
|
ValVUL_ptr->reserve(nelem);
|
|
|
|
switch (dataType) {
|
|
case CAFE_DOUBLE:
|
|
for (unsigned i=0; i<nelem; ++i) {
|
|
ValVUL_ptr->push_back((unsigned long) val[i].d);
|
|
}
|
|
break;
|
|
case CAFE_FLOAT:
|
|
for (unsigned i=0; i<nelem; ++i) {
|
|
ValVUL_ptr->push_back((unsigned long) val[i].f);
|
|
}
|
|
break;
|
|
case CAFE_LONG:
|
|
for (unsigned i=0; i<nelem; ++i) {
|
|
ValVUL_ptr->push_back((unsigned long) val[i].l);
|
|
}
|
|
break;
|
|
case CAFE_SHORT:
|
|
for (unsigned i=0; i<nelem; ++i) {
|
|
ValVUL_ptr->push_back((unsigned long) val[i].s);
|
|
}
|
|
break;
|
|
case CAFE_ENUM:
|
|
for (unsigned i=0; i<nelem; ++i) {
|
|
ValVUL_ptr->push_back((unsigned long) val[i].us);
|
|
}
|
|
break;
|
|
case CAFE_CHAR:
|
|
for (unsigned i=0; i<nelem; ++i) {
|
|
ValVUL_ptr->push_back((unsigned long) val[i].ch);
|
|
}
|
|
break;
|
|
case CAFE_STRING:
|
|
default:
|
|
for (unsigned i=0; i<nelem; ++i) {
|
|
ValVUL_ptr->push_back( getAsULong(i));
|
|
}
|
|
break;
|
|
}
|
|
|
|
return ValVUL_ptr;
|
|
#undef __METHOD__
|
|
}
|
|
|
|
|
|
|
|
|
|
boost::shared_ptr<std::vector<long long> > getAsVLongLong()
|
|
{
|
|
#define __METHOD__ "PVHolder::getAsVLongLong "
|
|
|
|
ValVLL_ptr.reset(new std::vector<long long>());
|
|
ValVLL_ptr->reserve(nelem);
|
|
|
|
switch (dataType) {
|
|
case CAFE_DOUBLE:
|
|
for (unsigned i=0; i<nelem; ++i) {
|
|
ValVLL_ptr->push_back((long long) val[i].d);
|
|
}
|
|
break;
|
|
case CAFE_FLOAT:
|
|
for (unsigned i=0; i<nelem; ++i) {
|
|
ValVLL_ptr->push_back((long long) val[i].f);
|
|
}
|
|
break;
|
|
case CAFE_LONG:
|
|
for (unsigned i=0; i<nelem; ++i) {
|
|
ValVLL_ptr->push_back((long long) val[i].l);
|
|
}
|
|
break;
|
|
case CAFE_SHORT:
|
|
for (unsigned i=0; i<nelem; ++i) {
|
|
ValVLL_ptr->push_back((long long) val[i].s);
|
|
}
|
|
break;
|
|
case CAFE_ENUM:
|
|
for (unsigned i=0; i<nelem; ++i) {
|
|
ValVLL_ptr->push_back((long long) val[i].us);
|
|
}
|
|
break;
|
|
case CAFE_CHAR:
|
|
for (unsigned i=0; i<nelem; ++i) {
|
|
ValVLL_ptr->push_back((long long) val[i].ch);
|
|
}
|
|
break;
|
|
case CAFE_STRING:
|
|
default:
|
|
for (unsigned i=0; i<nelem; ++i) {
|
|
ValVLL_ptr->push_back( getAsLongLong(i));
|
|
}
|
|
break;
|
|
}
|
|
|
|
return ValVLL_ptr;
|
|
#undef __METHOD__
|
|
}
|
|
|
|
|
|
boost::shared_ptr<std::vector<unsigned long long> > getAsVULongLong()
|
|
{
|
|
#define __METHOD__ "PVHolder::getAsVLongLong "
|
|
|
|
ValVULL_ptr.reset(new std::vector<unsigned long long>());
|
|
ValVULL_ptr->reserve(nelem);
|
|
|
|
switch (dataType) {
|
|
case CAFE_DOUBLE:
|
|
for (unsigned i=0; i<nelem; ++i) {
|
|
ValVULL_ptr->push_back((unsigned long long) val[i].d);
|
|
}
|
|
break;
|
|
case CAFE_FLOAT:
|
|
for (unsigned i=0; i<nelem; ++i) {
|
|
ValVULL_ptr->push_back((unsigned long long) val[i].f);
|
|
}
|
|
break;
|
|
case CAFE_LONG:
|
|
for (unsigned i=0; i<nelem; ++i) {
|
|
ValVULL_ptr->push_back((unsigned long long) val[i].l);
|
|
}
|
|
break;
|
|
case CAFE_SHORT:
|
|
for (unsigned i=0; i<nelem; ++i) {
|
|
ValVULL_ptr->push_back((unsigned long long) val[i].s);
|
|
}
|
|
break;
|
|
case CAFE_ENUM:
|
|
for (unsigned i=0; i<nelem; ++i) {
|
|
ValVULL_ptr->push_back((unsigned long long) val[i].us);
|
|
}
|
|
break;
|
|
case CAFE_CHAR:
|
|
for (unsigned i=0; i<nelem; ++i) {
|
|
ValVULL_ptr->push_back((unsigned long long) val[i].ch);
|
|
}
|
|
break;
|
|
case CAFE_STRING:
|
|
default:
|
|
for (unsigned i=0; i<nelem; ++i) {
|
|
ValVULL_ptr->push_back( getAsULongLong(i));
|
|
}
|
|
break;
|
|
}
|
|
|
|
return ValVULL_ptr;
|
|
#undef __METHOD__
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
boost::shared_ptr<std::vector<short> > getAsVShort()
|
|
{
|
|
#define __METHOD__ "PVHolder::getAsVShort "
|
|
|
|
ValVS_ptr.reset(new std::vector<short>());
|
|
ValVS_ptr->reserve(nelem);
|
|
|
|
switch (dataType) {
|
|
case CAFE_DOUBLE:
|
|
for (unsigned i=0; i<nelem; ++i) {
|
|
ValVS_ptr->push_back((short) val[i].d);
|
|
}
|
|
break;
|
|
case CAFE_FLOAT:
|
|
for (unsigned i=0; i<nelem; ++i) {
|
|
ValVS_ptr->push_back((short) val[i].f);
|
|
}
|
|
break;
|
|
case CAFE_LONG:
|
|
for (unsigned i=0; i<nelem; ++i) {
|
|
ValVS_ptr->push_back((short) val[i].l);
|
|
}
|
|
break;
|
|
case CAFE_SHORT:
|
|
for (unsigned i=0; i<nelem; ++i) {
|
|
ValVS_ptr->push_back(val[i].s);
|
|
}
|
|
break;
|
|
case CAFE_ENUM:
|
|
for (unsigned i=0; i<nelem; ++i) {
|
|
ValVS_ptr->push_back((short) val[i].us);
|
|
}
|
|
break;
|
|
case CAFE_CHAR:
|
|
for (unsigned i=0; i<nelem; ++i) {
|
|
ValVS_ptr->push_back((unsigned short) val[i].ch);
|
|
}
|
|
break;
|
|
case CAFE_STRING:
|
|
default:
|
|
for (unsigned i=0; i<nelem; ++i) {
|
|
ValVS_ptr->push_back( getAsShort(i));
|
|
}
|
|
break;
|
|
}
|
|
|
|
return ValVS_ptr;
|
|
#undef __METHOD__
|
|
}
|
|
|
|
|
|
|
|
boost::shared_ptr<std::vector<unsigned short> > getAsVUShort()
|
|
{
|
|
#define __METHOD__ "PVHolder::getAsVUShort "
|
|
|
|
ValVUS_ptr.reset(new std::vector<unsigned short>());
|
|
ValVUS_ptr->reserve(nelem);
|
|
|
|
switch (dataType) {
|
|
case CAFE_DOUBLE:
|
|
for (unsigned i=0; i<nelem; ++i) {
|
|
ValVUS_ptr->push_back((unsigned short) val[i].d);
|
|
}
|
|
break;
|
|
case CAFE_FLOAT:
|
|
for (unsigned i=0; i<nelem; ++i) {
|
|
ValVUS_ptr->push_back((unsigned short) val[i].f);
|
|
}
|
|
break;
|
|
case CAFE_LONG:
|
|
for (unsigned i=0; i<nelem; ++i) {
|
|
ValVUS_ptr->push_back((unsigned short) val[i].l);
|
|
}
|
|
break;
|
|
case CAFE_SHORT:
|
|
for (unsigned i=0; i<nelem; ++i) {
|
|
ValVUS_ptr->push_back((unsigned short)val[i].s);
|
|
}
|
|
break;
|
|
case CAFE_ENUM:
|
|
for (unsigned i=0; i<nelem; ++i) {
|
|
ValVUS_ptr->push_back( val[i].us);
|
|
}
|
|
break;
|
|
case CAFE_CHAR:
|
|
for (unsigned i=0; i<nelem; ++i) {
|
|
ValVUS_ptr->push_back((unsigned short) val[i].ch);
|
|
}
|
|
break;
|
|
case CAFE_STRING:
|
|
default:
|
|
for (unsigned i=0; i<nelem; ++i) {
|
|
ValVUS_ptr->push_back( getAsUShort(i));
|
|
}
|
|
break;
|
|
}
|
|
|
|
return ValVUS_ptr;
|
|
#undef __METHOD__
|
|
}
|
|
|
|
|
|
boost::shared_ptr<std::vector<unsigned char> > getAsVUChar()
|
|
{
|
|
#define __METHOD__ "PVHolder::getAsVUChar "
|
|
|
|
ValVC_ptr.reset(new std::vector<unsigned char>());
|
|
ValVC_ptr->reserve(nelem);
|
|
|
|
switch (dataType) {
|
|
case CAFE_DOUBLE:
|
|
for (unsigned i=0; i<nelem; ++i) {
|
|
ValVC_ptr->push_back((unsigned char) val[i].d);
|
|
}
|
|
break;
|
|
case CAFE_FLOAT:
|
|
for (unsigned i=0; i<nelem; ++i) {
|
|
ValVC_ptr->push_back((unsigned char) val[i].f);
|
|
}
|
|
break;
|
|
case CAFE_LONG:
|
|
for (unsigned i=0; i<nelem; ++i) {
|
|
ValVC_ptr->push_back((unsigned char) val[i].l);
|
|
}
|
|
break;
|
|
case CAFE_SHORT:
|
|
for (unsigned i=0; i<nelem; ++i) {
|
|
ValVC_ptr->push_back((unsigned char)val[i].s);
|
|
}
|
|
break;
|
|
case CAFE_ENUM:
|
|
for (unsigned i=0; i<nelem; ++i) {
|
|
ValVC_ptr->push_back( (unsigned char)val[i].us);
|
|
}
|
|
break;
|
|
case CAFE_CHAR:
|
|
for (unsigned i=0; i<nelem; ++i) {
|
|
ValVC_ptr->push_back((unsigned char) val[i].ch);
|
|
}
|
|
break;
|
|
case CAFE_STRING:
|
|
default:
|
|
for (unsigned i=0; i<nelem; ++i) {
|
|
ValVC_ptr->push_back( (unsigned char) getAsChar(i));
|
|
}
|
|
break;
|
|
}
|
|
|
|
return ValVC_ptr;
|
|
#undef __METHOD__
|
|
}
|
|
|
|
boost::shared_ptr<std::vector<std::string> > getAsVString()
|
|
{
|
|
#define __METHOD__ "PVHolder::getAsVString "
|
|
|
|
ValVStr_ptr.reset(new std::vector<std::string>());
|
|
ValVStr_ptr->reserve(nelem);
|
|
for (unsigned i=0; i<nelem; ++i) {
|
|
ValVStr_ptr->push_back( getAsString(i));
|
|
}
|
|
|
|
return ValVStr_ptr;
|
|
#undef __METHOD__
|
|
}
|
|
|
|
|
|
|
|
std::vector<std::string> getAsVectorString()
|
|
{
|
|
boost::shared_ptr<std::vector<std::string> > spVs = getAsVString();
|
|
return *spVs.get();
|
|
}
|
|
std::vector<float> getAsVectorFloat()
|
|
{
|
|
boost::shared_ptr<std::vector<float> > spVf = getAsVFloat();
|
|
return *spVf.get();
|
|
}
|
|
std::vector<double> getAsVectorDouble()
|
|
{
|
|
boost::shared_ptr<std::vector<double> > spVd = getAsVDouble();
|
|
return *spVd.get();
|
|
}
|
|
std::vector<int> getAsVectorInt()
|
|
{
|
|
boost::shared_ptr<std::vector<int> > spVi = getAsVInt();
|
|
return *spVi.get();
|
|
}
|
|
|
|
std::vector<long> getAsVectorLong()
|
|
{
|
|
boost::shared_ptr<std::vector<long> > spVl = getAsVLong();
|
|
return *spVl.get();
|
|
}
|
|
|
|
std::vector<unsigned long> getAsVectorULong()
|
|
{
|
|
boost::shared_ptr<std::vector<unsigned long> > spVul = getAsVULong();
|
|
return *spVul.get();
|
|
}
|
|
|
|
std::vector<long long> getAsVectorLongLong()
|
|
{
|
|
boost::shared_ptr<std::vector<long long> > spVll = getAsVLongLong();
|
|
return *spVll.get();
|
|
}
|
|
|
|
std::vector<unsigned long long> getAsVectorULongLong()
|
|
{
|
|
boost::shared_ptr<std::vector<unsigned long long> > spVull = getAsVULongLong();
|
|
return *spVull.get();
|
|
}
|
|
|
|
|
|
std::vector<short> getAsVectorShort()
|
|
{
|
|
boost::shared_ptr<std::vector<short> > spVsh = getAsVShort();
|
|
return *spVsh.get();
|
|
}
|
|
|
|
std::vector<unsigned short> getAsVectorUShort()
|
|
{
|
|
boost::shared_ptr<std::vector<unsigned short> > spVus = getAsVUShort();
|
|
return *spVus.get();
|
|
}
|
|
std::vector<unsigned char> getAsVectorUChar()
|
|
{
|
|
boost::shared_ptr<std::vector<unsigned char> > spVc = getAsVUChar();
|
|
return *spVc.get();
|
|
}
|
|
|
|
|
|
ValDPtr getDouble()
|
|
{
|
|
#define __METHOD__ "PVHolder::getDouble "
|
|
if (dataType!=CAFE_DOUBLE) {
|
|
std::cout << "******* WARNING *******" << std::endl;
|
|
std::cout << __METHOD__ << __LINE__ << std::endl;
|
|
std::cout << "DataType is " << (cafeDataTypeCode.message((CAFE_DATATYPE)dataType)).c_str() <<
|
|
" hence getDouble method is invalid! " << std::endl;
|
|
std::cout << "Use getAsDouble method if you wish to retrieve the data as a double! " << std::endl;
|
|
std::cout << "**********************" << std::endl;
|
|
}
|
|
|
|
ValD_ptr.reset(new double[nelem]);
|
|
|
|
for (unsigned i=0; i<nelem; ++i) {
|
|
ValD_ptr[i] = val[i].d;
|
|
}
|
|
|
|
return ValD_ptr;
|
|
#undef __METHOD__
|
|
}
|
|
|
|
ValFPtr getFloat()
|
|
{
|
|
#define __METHOD__ "PVHolder::getFloat "
|
|
if (dataType!=CAFE_FLOAT) {
|
|
std::cout << "******* WARNING *******" << std::endl;
|
|
std::cout << __METHOD__ << __LINE__ << std::endl;
|
|
std::cout << "DataType is " << (cafeDataTypeCode.message((CAFE_DATATYPE)dataType)).c_str() <<
|
|
" hence getFloat method is invalid! " << std::endl;
|
|
std::cout << "Use getAsFloat method if you wish to retrieve the data as a float! " << std::endl;
|
|
std::cout << "**********************" << std::endl;
|
|
}
|
|
ValF_ptr.reset(new float[nelem]);
|
|
for (unsigned i=0; i<nelem; ++i) {
|
|
ValF_ptr[i] = val[i].f;
|
|
}
|
|
return ValF_ptr;
|
|
//return (float *) val.get();
|
|
#undef __METHOD__
|
|
}
|
|
|
|
ValSPtr getShort()
|
|
{
|
|
#define __METHOD__ "PVHolder::getShort "
|
|
if (dataType==CAFE_SHORT) {
|
|
std::cout << "******* WARNING *******" << std::endl;
|
|
std::cout << __METHOD__ << __LINE__ << std::endl;
|
|
std::cout << "DataType is " << (cafeDataTypeCode.message((CAFE_DATATYPE)dataType)).c_str() <<
|
|
" hence getShort method is invalid! " << std::endl;
|
|
std::cout << "Use getAsShort method if you wish to retrieve the data as a short! " << std::endl;
|
|
std::cout << "**********************" << std::endl;
|
|
}
|
|
ValS_ptr.reset(new short[nelem]);
|
|
for (unsigned i=0; i<nelem; ++i) {
|
|
ValS_ptr[i] = val[i].s;
|
|
}
|
|
return ValS_ptr;
|
|
|
|
#undef __METHOD__
|
|
}
|
|
|
|
ValIPtr getInt()
|
|
{
|
|
#define __METHOD__ "PVHolder::getInt (meaning dbr_long_t) "
|
|
if (dataType!=CAFE_LONG) {
|
|
std::cout << "******* WARNING *******" << std::endl;
|
|
std::cout << __METHOD__ << __LINE__ << std::endl;
|
|
std::cout << "DataType is " << (cafeDataTypeCode.message((CAFE_DATATYPE)dataType)).c_str() <<
|
|
" hence getInt method is invalid! " << std::endl;
|
|
std::cout << "Use getAsInt method if you wish to retrieve the data as a int! " << std::endl;
|
|
std::cout << "**********************" << std::endl;
|
|
}
|
|
ValI_ptr.reset(new int[nelem]);
|
|
for (unsigned i=0; i<nelem; ++i) {
|
|
ValI_ptr[i] = val[i].l;
|
|
}
|
|
return ValI_ptr;
|
|
#undef __METHOD__
|
|
}
|
|
|
|
ValIPtr getLong()
|
|
{
|
|
#define __METHOD__ "PVHolder::getLong (meaning dbr_long_t) "
|
|
if (dataType!=CAFE_LONG) {
|
|
std::cout << "******* WARNING *******" << std::endl;
|
|
std::cout << __METHOD__ << __LINE__ << std::endl;
|
|
std::cout << "DataType is " << (cafeDataTypeCode.message((CAFE_DATATYPE)dataType)).c_str() <<
|
|
" hence getLong method is invalid! " << std::endl;
|
|
std::cout << "Use getAsLong method if you wish to retrieve the data as a dbr_long_t! " << std::endl;
|
|
std::cout << "**********************" << std::endl;
|
|
}
|
|
ValI_ptr.reset(new int[nelem]);
|
|
for (unsigned i=0; i<nelem; ++i) {
|
|
ValI_ptr[i] = val[i].l;
|
|
}
|
|
return ValI_ptr;
|
|
#undef __METHOD__
|
|
}
|
|
|
|
ValUSPtr getEnum()
|
|
{
|
|
#define __METHOD__ "PVHolder::getEnum "
|
|
if (dataType!=CAFE_ENUM) {
|
|
std::cout << "******* WARNING *******" << std::endl;
|
|
std::cout << __METHOD__ << __LINE__ << std::endl;
|
|
std::cout << "DataType is " << (cafeDataTypeCode.message((CAFE_DATATYPE)dataType)).c_str() <<
|
|
" hence getEnum method is invalid! " << std::endl;
|
|
std::cout << "Use getAsEnum method if you wish to retrieve the data as an enum (unsigned short)! " << std::endl;
|
|
std::cout << "**********************" << std::endl;
|
|
}
|
|
ValUS_ptr.reset(new unsigned short[nelem]);
|
|
for (unsigned i=0; i<nelem; ++i) {
|
|
ValUS_ptr[i] = val[i].us;
|
|
}
|
|
return ValUS_ptr;
|
|
#undef __METHOD__
|
|
}
|
|
|
|
ValUSPtr getUShort()
|
|
{
|
|
#define __METHOD__ "PVHolder::getUShort "
|
|
if (dataType!=CAFE_USHORT) {
|
|
std::cout << "******* WARNING *******" << std::endl;
|
|
std::cout << __METHOD__ << __LINE__ << std::endl;
|
|
std::cout << "DataType is " << (cafeDataTypeCode.message((CAFE_DATATYPE)dataType)).c_str() <<
|
|
" hence getUShort method is invalid! " << std::endl;
|
|
std::cout << "Use getAsUSHort method if you wish to retrieve the data as an unsigned short! " << std::endl;
|
|
std::cout << "**********************" << std::endl;
|
|
}
|
|
ValUS_ptr.reset(new unsigned short[nelem]);
|
|
for (unsigned i=0; i<nelem; ++i) {
|
|
ValUS_ptr[i] = val[i].us;
|
|
}
|
|
return ValUS_ptr;
|
|
#undef __METHOD__
|
|
}
|
|
|
|
ValChPtr getChar()
|
|
{
|
|
#define __METHOD__ "PVHolder::getChar "
|
|
if (dataType!=CAFE_CHAR) {
|
|
std::cout << "******* WARNING *******" << std::endl;
|
|
std::cout << __METHOD__ << __LINE__ << std::endl;
|
|
std::cout << "DataType is " << (cafeDataTypeCode.message((CAFE_DATATYPE)dataType)).c_str() <<
|
|
" hence getChar method is invalid! " << std::endl;
|
|
std::cout << "Use getAsChar method if you wish to retrieve the data as a char! " << std::endl;
|
|
std::cout << "**********************" << std::endl;
|
|
}
|
|
ValCh_ptr.reset(new unsigned char[nelem]);
|
|
for (unsigned i=0; i<nelem; ++i) {
|
|
ValCh_ptr[i] = val[i].ch;
|
|
}
|
|
return ValCh_ptr;
|
|
#undef __METHOD__
|
|
}
|
|
|
|
ValStrPtr getString()
|
|
{
|
|
#define __METHOD__ "PVHolder::getString "
|
|
if (dataType!=CAFE_STRING) {
|
|
std::cout << "******* WARNING *******" << std::endl;
|
|
std::cout << __METHOD__ << __LINE__ << std::endl;
|
|
std::cout << "DataType is " << (cafeDataTypeCode.message((CAFE_DATATYPE)dataType)).c_str() <<
|
|
" hence getString method is invalid! " << std::endl;
|
|
std::cout << "Use getAsString method if you wish to retrieve the data as a string! " << std::endl;
|
|
std::cout << "**********************" << std::endl;
|
|
//return (dbr_string_t *) "";
|
|
}
|
|
ValStr_ptr.reset(new dbr_string_t[nelem]);
|
|
for (unsigned i=0; i<nelem; ++i) {
|
|
strcpy(ValStr_ptr[i], val[i].str);
|
|
}
|
|
return ValStr_ptr;
|
|
#undef __METHOD__
|
|
}
|
|
|
|
double getAsDouble ()
|
|
{
|
|
return (double) renderDouble.get(0, dataType, val.get())[0];
|
|
}
|
|
|
|
double getAsDouble(unsigned int idx) throw(std::out_of_range)
|
|
{
|
|
if(isIndexOutOfRange(idx)) {
|
|
std::ostringstream oss;
|
|
oss << "Exception! Index " << idx
|
|
<< " to PVHolder method is out of range. Valid range is from 0 to " << size-1;
|
|
throw std::out_of_range(oss.str());
|
|
}
|
|
return (double) renderDouble.get(idx, dataType, val.get())[0];
|
|
}
|
|
|
|
float getAsFloat ()
|
|
{
|
|
return (float) renderFloat.get(0, dataType, val.get())[0];
|
|
}
|
|
|
|
float getAsFloat(unsigned int idx) throw(std::out_of_range)
|
|
{
|
|
if(isIndexOutOfRange(idx)) {
|
|
std::ostringstream oss;
|
|
oss << "Exception! Index " << idx
|
|
<< " to PVHolder method is out of range. Valid range is from 0 to " << size-1;
|
|
throw std::out_of_range(oss.str());
|
|
}
|
|
return (float) renderFloat.get(idx, dataType, val.get())[0];
|
|
}
|
|
|
|
short getAsShort ()
|
|
{
|
|
return (short) renderShort.get(0, dataType, val.get())[0];
|
|
}
|
|
|
|
short getAsShort(unsigned int idx) throw(std::out_of_range)
|
|
{
|
|
if(isIndexOutOfRange(idx)) {
|
|
std::ostringstream oss;
|
|
oss << "Exception! Index " << idx
|
|
<< " to PVHolder method is out of range. Valid range is from 0 to " << size-1;
|
|
throw std::out_of_range(oss.str());
|
|
}
|
|
return (short) renderShort.get(idx, dataType, val.get())[0];
|
|
}
|
|
|
|
int getAsLong ()
|
|
{
|
|
return (int) renderLong.get(0, dataType, val.get())[0];
|
|
}
|
|
|
|
int getAsLong(unsigned int idx) throw(std::out_of_range)
|
|
{
|
|
if(isIndexOutOfRange(idx)) {
|
|
std::ostringstream oss;
|
|
oss << "Exception! Index " << idx
|
|
<< " to PVHolder method is out of range. Valid range is from 0 to " << size-1;
|
|
throw std::out_of_range(oss.str());
|
|
}
|
|
return (int) renderLong.get(idx, dataType, val.get())[0];
|
|
}
|
|
|
|
unsigned short getAsEnum ()
|
|
{
|
|
return (unsigned short) renderEnum.get(0, dataType, val.get())[0];
|
|
}
|
|
|
|
unsigned short getAsEnum(unsigned int idx) throw(std::out_of_range)
|
|
{
|
|
if(isIndexOutOfRange(idx)) {
|
|
std::ostringstream oss;
|
|
oss << "Exception! Index " << idx
|
|
<< " to PVHolder method is out of range. Valid range is from 0 to " << size-1;
|
|
throw std::out_of_range(oss.str());
|
|
}
|
|
return (unsigned short) renderEnum.get(idx, dataType, val.get())[0];
|
|
}
|
|
|
|
unsigned short getAsUShort ()
|
|
{
|
|
return (unsigned short) renderEnum.get(0, dataType, val.get())[0];
|
|
}
|
|
|
|
unsigned short getAsUShort(unsigned int idx) throw(std::out_of_range)
|
|
{
|
|
if(isIndexOutOfRange(idx)) {
|
|
std::ostringstream oss;
|
|
oss << "Exception! Index " << idx
|
|
<< " to PVHolder method is out of range. Valid range is from 0 to " << size-1;
|
|
throw std::out_of_range(oss.str());
|
|
}
|
|
return (unsigned short) renderEnum.get(idx, dataType, val.get())[0];
|
|
}
|
|
|
|
unsigned char getAsChar ()
|
|
{
|
|
return (char) renderChar.get(0, dataType, val.get())[0];
|
|
}
|
|
|
|
unsigned char getAsChar(unsigned int idx) throw(std::out_of_range)
|
|
{
|
|
if(isIndexOutOfRange(idx)) {
|
|
std::ostringstream oss;
|
|
oss << "Exception! Index " << idx
|
|
<< " to PVHolder method is out of range. Valid range is from 0 to " << size-1;
|
|
throw std::out_of_range(oss.str());
|
|
}
|
|
return (char) renderChar.get(idx, dataType, val.get())[0];
|
|
}
|
|
|
|
unsigned char getAsUChar ()
|
|
{
|
|
return (unsigned char) renderUChar.get(0, dataType, val.get())[0];
|
|
}
|
|
|
|
unsigned char getAsUChar(unsigned int idx) throw(std::out_of_range)
|
|
{
|
|
if(isIndexOutOfRange(idx)) {
|
|
std::ostringstream oss;
|
|
oss << "Exception! Index " << idx
|
|
<< " to PVHolder method is out of range. Valid range is from 0 to " << size-1;
|
|
throw std::out_of_range(oss.str());
|
|
}
|
|
return (unsigned char) renderUChar.get(idx, dataType, val.get())[0];
|
|
}
|
|
|
|
unsigned int getAsULong ()
|
|
{
|
|
return (unsigned int) renderULong.get(0, dataType, val.get())[0];
|
|
}
|
|
|
|
unsigned int getAsULong(unsigned int idx) throw(std::out_of_range)
|
|
{
|
|
if(isIndexOutOfRange(idx)) {
|
|
std::ostringstream oss;
|
|
oss << "Exception! Index " << idx
|
|
<< " to PVHolder method is out of range. Valid range is from 0 to " << size-1;
|
|
throw std::out_of_range(oss.str());
|
|
}
|
|
return (unsigned int) renderULong.get(idx, dataType, val.get())[0];
|
|
}
|
|
|
|
long long getAsLongLong ()
|
|
{
|
|
return (long long) renderLongLong.get(0, dataType, val.get())[0];
|
|
}
|
|
|
|
long long getAsLongLong(unsigned int idx) throw(std::out_of_range)
|
|
{
|
|
if(isIndexOutOfRange(idx)) {
|
|
std::ostringstream oss;
|
|
oss << "Exception! Index " << idx
|
|
<< " to PVHolder method is out of range. Valid range is from 0 to " << size-1;
|
|
throw std::out_of_range(oss.str());
|
|
}
|
|
return (long long) renderLongLong.get(idx, dataType, val.get())[0];
|
|
}
|
|
|
|
unsigned long long getAsULongLong ()
|
|
{
|
|
return (unsigned long long) renderULongLong.get(0, dataType, val.get())[0];
|
|
}
|
|
|
|
unsigned long long getAsULongLong(unsigned int idx) throw(std::out_of_range)
|
|
{
|
|
if(isIndexOutOfRange(idx)) {
|
|
std::ostringstream oss;
|
|
oss << "Exception! Index " << idx
|
|
<< " to PVHolder method is out of range. Valid range is from 0 to " << size-1;
|
|
throw std::out_of_range(oss.str());
|
|
}
|
|
return (unsigned long long) renderULongLong.get(idx, dataType, val.get())[0];
|
|
}
|
|
|
|
int getAsInt ()
|
|
{
|
|
return (int) renderInt.get(0, dataType, val.get())[0];
|
|
}
|
|
|
|
int getAsInt(unsigned int idx) throw(std::out_of_range)
|
|
{
|
|
if(isIndexOutOfRange(idx)) {
|
|
std::ostringstream oss;
|
|
oss << "Exception! Index " << idx
|
|
<< " to PVHolder method is out of range. Valid range is from 0 to " << size-1;
|
|
throw std::out_of_range(oss.str());
|
|
}
|
|
return (int) renderInt.get(idx, dataType, val.get())[0];
|
|
}
|
|
|
|
unsigned int getAsUInt ()
|
|
{
|
|
return (unsigned int) renderInt.get(0, dataType, val.get())[0];
|
|
}
|
|
|
|
unsigned int getAsUInt(unsigned int idx) throw(std::out_of_range)
|
|
{
|
|
if(isIndexOutOfRange(idx)) {
|
|
std::ostringstream oss;
|
|
oss << "Exception! Index " << idx
|
|
<< " to PVHolder method is out of range. Valid range is from 0 to " << size-1;
|
|
throw std::out_of_range(oss.str());
|
|
}
|
|
return (unsigned int) renderInt.get(idx, dataType, val.get())[0];
|
|
}
|
|
|
|
//getEnumAsNumberedString
|
|
std::string getEnumIntegerValueAsString()
|
|
{
|
|
#define __METHOD__ "PVHolder::getEnumIntegerValueAsString"
|
|
if (dataType!=CAFE_ENUM) {
|
|
std::cout << "******* WARNING *******" << std::endl;
|
|
std::cout << __METHOD__ << __LINE__ << std::endl;
|
|
std::cout << "DataType is " << (cafeDataTypeCode.message((CAFE_DATATYPE)dataType)).c_str() <<
|
|
" hence getEnumIntegerValueAsString method is invalid! " << std::endl;
|
|
std::cout << "Use getAsString method if you want the string equilavent of the ENUM value!" << std::endl;
|
|
std::cout << "**********************" << std::endl;
|
|
}
|
|
return (std::string) renderString.getString(0, dataType, val.get())[0];
|
|
#undef __METHOD__
|
|
}
|
|
|
|
std::string getAsString()
|
|
{
|
|
if(dataTypeNative==DBR_ENUM && dataType==DBR_ENUM) {
|
|
|
|
return (std::string) renderString.getStringFromEnum(0, noStr, val.get(), strs)[0];
|
|
}
|
|
else {
|
|
return (std::string) renderString.getString(0, dataType, val.get())[0];
|
|
}
|
|
}
|
|
|
|
std::string getAsString(unsigned int idx) throw(std::out_of_range)
|
|
{
|
|
if(isIndexOutOfRange(idx)) {
|
|
std::ostringstream oss;
|
|
oss << "Exception! Index " << idx
|
|
<< " to PVHolder method is out of range. Valid range is from 0 to " << size-1;
|
|
throw std::out_of_range(oss.str());
|
|
}
|
|
if(dataTypeNative==DBR_ENUM && dataType==CAFE_ENUM) {
|
|
return (std::string) renderString.getStringFromEnum(idx, noStr, val.get(), strs)[0];
|
|
}
|
|
else {
|
|
return (std::string) renderString.getString(idx, dataType, val.get())[0];
|
|
}
|
|
}
|
|
|
|
|
|
char * getAsDbr_string_t()
|
|
{
|
|
if(dataTypeNative==DBR_ENUM && dataType==CAFE_ENUM) {
|
|
return (char *) renderString.getStringFromEnum(0, noStr, val.get(), strs)[0];
|
|
|
|
}
|
|
else {
|
|
return (char *) renderString.getString(0, dataType, val.get())[0];
|
|
}
|
|
}
|
|
|
|
|
|
char * getAsDbr_string_t(unsigned int idx) throw(std::out_of_range)
|
|
{
|
|
if(isIndexOutOfRange(idx)) {
|
|
std::ostringstream oss;
|
|
oss << "Exception! Index " << idx
|
|
<< " to PVHolder method is out of range. Valid range is from 0 to " << size-1;
|
|
throw std::out_of_range(oss.str());
|
|
}
|
|
if(dataTypeNative==DBR_ENUM && dataType==CAFE_ENUM) {
|
|
return (char *) renderString.getStringFromEnum(idx, noStr, val.get(), strs)[0];
|
|
}
|
|
else {
|
|
return (char *) renderString.getString(idx, dataType, val.get())[0];
|
|
}
|
|
}
|
|
|
|
/*
|
|
dbr_string_t * getAsDbr_string_t(unsigned int idx) throw(std::out_of_range){
|
|
if(isIndexOutOfRange(idx)) {
|
|
std::ostringstream oss;
|
|
oss << "Exception! Index " << idx
|
|
<< " to PVHolder method is out of range. Valid range is from 0 to " << size-1;
|
|
throw std::out_of_range(oss.str());
|
|
}
|
|
if(dataTypeNative==DBR_ENUM && dataType==CAFE_ENUM) {
|
|
return (dbr_string_t *) renderString.getStringFromEnum(idx, val.get(), strs);
|
|
}
|
|
else {
|
|
return (dbr_string_t *) renderString.getString(idx, dataType, val.get());
|
|
}
|
|
}
|
|
*/
|
|
|
|
//used by PVCtrlHolder
|
|
double getAsDouble(CAFE_DATATYPE_UNION cdu)
|
|
{
|
|
return (double) renderDouble.get(0, dataType, &cdu)[0];
|
|
}
|
|
|
|
float getAsFloat(CAFE_DATATYPE_UNION cdu)
|
|
{
|
|
return (float) renderFloat.get(0, dataType, &cdu)[0];
|
|
}
|
|
|
|
short getAsShort(CAFE_DATATYPE_UNION cdu)
|
|
{
|
|
return (short) renderShort.get(0, dataType, &cdu)[0];
|
|
}
|
|
|
|
int getAsLong(CAFE_DATATYPE_UNION cdu)
|
|
{
|
|
return (int) renderLong.get(0, dataType, &cdu)[0];
|
|
}
|
|
|
|
unsigned short getAsEnum(CAFE_DATATYPE_UNION cdu)
|
|
{
|
|
return (unsigned short) renderEnum.get(0, dataType, &cdu)[0];
|
|
}
|
|
|
|
unsigned short getAsUShort(CAFE_DATATYPE_UNION cdu)
|
|
{
|
|
return (unsigned short) renderEnum.get(0, dataType, &cdu)[0];
|
|
}
|
|
|
|
char getAsChar(CAFE_DATATYPE_UNION cdu)
|
|
{
|
|
char * ans = renderChar.get(0, dataType, &cdu);
|
|
return (char ) ans[0];
|
|
}
|
|
unsigned char getAsUChar(CAFE_DATATYPE_UNION cdu)
|
|
{
|
|
unsigned char * ans = renderUChar.get(0, dataType, &cdu);
|
|
return (unsigned char ) ans[0];
|
|
}
|
|
|
|
std::string getAsString(CAFE_DATATYPE_UNION cdu)
|
|
{
|
|
return (std::string) renderString.getString(dataType, cdu)[0];
|
|
}
|
|
|
|
char * getAsDbr_string_t(CAFE_DATATYPE_UNION cdu)
|
|
{
|
|
return (char *) renderString.getString(0, dataType, &cdu)[0];
|
|
}
|
|
};
|
|
|
|
|
|
#endif //PVHOLDER_H
|