00001
00002
00003
00004
00005
00006
00007
00008 #ifndef PVHOLDER_H
00009 #define PVHOLDER_H
00010
00011 #include <stdexcept>
00012 #include <cstring>
00013 #include <limits>
00014 #include <cafeConvert.h>
00015 #include <statusCodes.h>
00016 #include <helper.h>
00017 #include <defines.h>
00018 #include <cafeDataTypeHelper.h>
00019 #include <boost/smart_ptr/shared_ptr.hpp>
00020
00021
00022 #include <vector>
00023
00024
00030 class PVHolder {
00031
00032 protected:
00033 char pv [PVNAME_SIZE];
00034 char pvAlias[PVNAME_SIZE];
00035 char device [PVNAME_SIZE];
00036 char attrib [PVNAME_SIZE];
00037
00038 CAFE_DATATYPE dataTypeNative;
00039 CAFE_DATATYPE dataType;
00040 CAFEDataTypeCode cafeDataTypeCode;
00041 CAFEStatusCode cafeStatusCode;
00042
00043 chtype dbrDataType;
00044
00045 unsigned int size;
00046 unsigned int nelem;
00047
00048 short alarmStatus;
00049 short alarmSeverity;
00050
00051 CAFEGlobalAlarmCondition acond;
00052 CAFEGlobalAlarmSeverity aseve;
00053
00054 unsigned int userNo;
00055
00056 unsigned long long beamEventNo;
00057
00058 bool rule;
00059 bool hasAlarm;
00060 int status;
00061
00062 short noStr;
00063 char strs [MAX_ENUM_STATES][MAX_ENUM_STRING_SIZE];
00064
00065 CAFEConvert<double> renderDouble;
00066 CAFEConvert<float> renderFloat;
00067 CAFEConvert<short> renderShort;
00068 CAFEConvert<int> renderLong;
00069 CAFEConvert<unsigned short> renderEnum;
00070 CAFEConvert<unsigned char> renderUChar;
00071 CAFEConvert<dbr_string_t> renderString;
00072
00073 CAFEConvert<char> renderChar;
00074 CAFEConvert<unsigned int> renderULong;
00075 CAFEConvert<long long> renderLongLong;
00076 CAFEConvert<unsigned long long> renderULongLong;
00077
00078 CAFEConvert<int> renderInt;
00079 CAFEConvert<unsigned int> renderUInt;
00080
00081
00082 void verifyIndex(unsigned int idx) {
00083 if(idx >= size) {
00084 std::ostringstream oss;
00085 oss << "Exception! Index " << idx
00086 << " to PVHolder method is out of range. Valid range is from 0 to " << size-1;
00087 throw std::out_of_range(oss.str());
00088 }
00089 };
00090
00091 bool isIndexOutOfRange (unsigned int idx) {
00092 return (idx >= size) ? true:false;
00093 };
00094
00095
00096 public:
00097
00098 typedef boost::shared_ptr<CAFE_DATATYPE_UNION []> ValPtr;
00099
00100 ValPtr val;
00101
00102 boost::shared_ptr<std::vector<double> > ValVD_ptr;
00103 boost::shared_ptr<std::vector<float> > ValVF_ptr;
00104 boost::shared_ptr<std::vector<short> > ValVS_ptr;
00105 boost::shared_ptr<std::vector<int> > ValVI_ptr;
00106 boost::shared_ptr<std::vector<long> > ValVL_ptr;
00107 boost::shared_ptr<std::vector<unsigned long> > ValVUL_ptr;
00108 boost::shared_ptr<std::vector<long long> > ValVLL_ptr;
00109 boost::shared_ptr<std::vector<unsigned long long> > ValVULL_ptr;
00110 boost::shared_ptr<std::vector<unsigned char> > ValVC_ptr;
00111 boost::shared_ptr<std::vector<unsigned short> > ValVUS_ptr;
00112 boost::shared_ptr<std::vector<std::string> > ValVStr_ptr;
00113
00114 typedef boost::shared_ptr<double []> ValDPtr;
00115 typedef boost::shared_ptr<float []> ValFPtr;
00116 typedef boost::shared_ptr<short []> ValSPtr;
00117 typedef boost::shared_ptr<int []> ValIPtr;
00118 typedef boost::shared_ptr<unsigned char []> ValChPtr;
00119 typedef boost::shared_ptr<unsigned short []> ValUSPtr;
00120 typedef boost::shared_ptr<dbr_string_t []> ValStrPtr;
00121
00122 ValDPtr ValD_ptr;
00123 ValFPtr ValF_ptr;
00124 ValSPtr ValS_ptr;
00125 ValIPtr ValI_ptr;
00126 ValChPtr ValCh_ptr;
00127 ValUSPtr ValUS_ptr;
00128 ValStrPtr ValStr_ptr;
00129
00130 void setUserNo(unsigned int un) {
00131 userNo=un;
00132 return;
00133 }
00134
00135 unsigned int getUserNo() {
00136 return userNo;
00137 }
00138
00139
00140 void setRule(bool r) {
00141 rule=r;
00142 return;
00143 };
00144
00145 void setBeamEventNo (unsigned long long b) {beamEventNo=b;}
00146 void setPulseID (unsigned long long b) {beamEventNo=b;}
00147 void setStatus (int st) {status=st;}
00148 void setAlarmStatus (int ast) {alarmStatus=ast;}
00149 void setAlarmSeverity(int asev) {alarmSeverity=asev;}
00150
00151 const char * getPV() const {return pv;};
00152 const char * getPVName() const {return pv;};
00153 const char * getPVAlias() const {return pvAlias;};
00154 const char * getDevice() const {return device;};
00155 const char * getAttribute() const {return attrib;};
00156 unsigned int getNelem() const {return nelem;};
00157
00158 const unsigned int getSize() const {return size;};
00159 CAFE_DATATYPE_UNION_SEQ getVal() const {return val.get();};
00160
00161
00162 short getAlarmStatus() const {return alarmStatus;};
00163 short getAlarmSeverity() const {return alarmSeverity;};
00164
00165 std::string getAlarmStatusAsString() {return acond.asString(alarmStatus);};
00166 std::string getAlarmSeverityAsString() {return aseve.asString(alarmSeverity);};
00167
00168 unsigned long long getBeamEventNo() const {return beamEventNo;};
00169 unsigned long long getPulseID() const {return beamEventNo;};
00170 bool getRule() const {return rule;};
00171 bool getHasAlarm() const{return hasAlarm;};
00172 int getStatus() const {return status;};
00173 std::string getStatusAsString() {return cafeStatusCode.msgIDAsString(status); };
00174 CAFE_DATATYPE getDataTypeClient() const {return dataType;};
00175 CAFE_DATATYPE getDataType() const {return dataType;};
00176
00177 CAFEStatusCode getStatusCode() const {return cafeStatusCode;};
00178
00179 short getNoEnumStrings () const {return noStr;};
00180 char * getEnumString(short indx) const {return (char *) strs[indx]; }
00181
00182 void setDataType(CAFE_DATATYPE cdt){
00183 if (cdt > CAFE_DOUBLE || cdt < CAFE_STRING) {
00184 std::cout << "WARNING: INPUT VALUE NOT A VALID CAFE DATATYPE " << std::endl;
00185 return;
00186 } else {dataType=cdt; return;}};
00187
00188 void set(double d) {val[0].d=d; dataType=CAFE_DOUBLE;};
00189 void set(float f) {val[0].f=f; dataType=CAFE_FLOAT;};
00190 void set(short s) {val[0].s=s; dataType=CAFE_SHORT;};
00191 void set(long long l) {
00192 if (l > std::numeric_limits<dbr_long_t>::max()) {
00193 std::cout << "WARNING: INPUT VALUE GREATER THAN MAX LIMIT OF dbr_long_t " << std::endl;
00194 std::cout << "TYPE CASTING TO DOUBLE! " << std::endl;
00195 val[0].d= (double) l; dataType=CAFE_DOUBLE;}
00196 else {
00197 val[0].l= (int) l; dataType=CAFE_LONG;};
00198 }
00199 void set(int l) {val[0].l=l; dataType=CAFE_LONG;};
00200 void set(unsigned long long l) {
00201 if (l > (unsigned long long) std::numeric_limits<dbr_long_t>::max()) {
00202 std::cout << "WARNING: INPUT VALUE GREATER THAN MAX LIMIT OF dbr_long_t " << std::endl;
00203 std::cout << "TYPE CASTING TO DOUBLE! " << std::endl;
00204 val[0].d= (double) l; dataType=CAFE_DOUBLE;}
00205 else {
00206 val[0].l= (int) l; dataType=CAFE_LONG;};
00207 }
00208
00209
00210 void setString(std::string str) {strcpy(val[0].str,str.c_str()); dataType=CAFE_STRING;};
00211 void setDouble(double d) {val[0].d=d; dataType=CAFE_DOUBLE;};
00212 void setInt(int l) {val[0].l=l; dataType=CAFE_LONG;};
00213
00214
00215 void setVString(std::vector<std::string> Vstr) {
00216 if(Vstr.size()!=nelem) {nelem=Vstr.size();}
00217 for (unsigned int i=0; i<nelem; ++ i) {
00218 strcpy(val[i].str,Vstr[i].c_str());} dataType=CAFE_STRING;};
00219 void setVDouble(std::vector<double> Vd) {
00220 if(Vd.size()!=nelem) {nelem=Vd.size();}
00221 for (unsigned int i=0; i<nelem; ++ i) {
00222 val[i].d=Vd[i];} dataType=CAFE_DOUBLE;};
00223 void setVInt (std::vector<int> Vl) {
00224 if(Vl.size()!=nelem) {nelem=Vl.size();}
00225 for (unsigned int i=0; i<nelem; ++ i) {
00226 val[i].l=Vl[i];} dataType=CAFE_LONG;};
00227
00228
00229
00230
00231 void set(std::vector<std::string> Vstr) {
00232 if(Vstr.size()!=nelem) {nelem=Vstr.size();}
00233 for (unsigned int i=0; i<nelem; ++ i) {
00234 strcpy(val[i].str,Vstr[i].c_str());} dataType=CAFE_STRING;};
00235 void set(std::vector<double> Vd) {
00236 if(Vd.size()!=nelem) {nelem=Vd.size();}
00237 for (unsigned int i=0; i<nelem; ++ i) {
00238 val[i].d=Vd[i];} dataType=CAFE_DOUBLE;};
00239 void set(std::vector<float> Vf) {
00240 if(Vf.size()!=nelem) {nelem=Vf.size();}
00241 for (unsigned int i=0; i<nelem; ++ i) {
00242 val[i].f=Vf[i];} dataType=CAFE_FLOAT;};
00243
00244 void set (std::vector<int> Vl) {
00245 if(Vl.size()!=nelem) {nelem=Vl.size();}
00246 for (unsigned int i=0; i<nelem; ++ i) {
00247 val[i].l=Vl[i];} dataType=CAFE_LONG;};
00248
00249 void set (std::vector<long> Vl) {
00250 if(Vl.size()!=nelem) {nelem=Vl.size();}
00251 for (unsigned int i=0; i<nelem; ++ i) {
00252 val[i].l=Vl[i];} dataType=CAFE_LONG;};
00253
00254 void set (std::vector<unsigned long> Vul) {
00255 if(Vul.size()!=nelem) {nelem=Vul.size();}
00256 for (unsigned int i=0; i<nelem; ++ i) {
00257 val[i].d=Vul[i];} dataType=CAFE_DOUBLE;};
00258
00259 void set (std::vector<long long> Vll) {
00260 if(Vll.size()!=nelem) {nelem=Vll.size();}
00261 for (unsigned int i=0; i<nelem; ++ i) {
00262 val[i].d=Vll[i];} dataType=CAFE_DOUBLE;};
00263
00264 void set (std::vector<unsigned long long> Vull) {
00265 if(Vull.size()!=nelem) {nelem=Vull.size();}
00266 for (unsigned int i=0; i<nelem; ++ i) {
00267 val[i].d=Vull[i];} dataType=CAFE_DOUBLE;};
00268
00269 void set (std::vector<short> Vs) {
00270 if(Vs.size()!=nelem) {nelem=Vs.size();}
00271 for (unsigned int i=0; i<nelem; ++ i) {
00272 val[i].s=Vs[i];} dataType=CAFE_SHORT;};
00273
00274 void set (std::vector<unsigned short> Vus) {
00275 if(Vus.size()!=nelem) {nelem=Vus.size();}
00276 for (unsigned int i=0; i<nelem; ++ i) {
00277 val[i].us=Vus[i];} dataType=CAFE_ENUM;};
00278
00279 void set (std::vector<unsigned char> Vc) {
00280 if(Vc.size()!=nelem) {nelem=Vc.size();}
00281 for (unsigned int i=0; i<nelem; ++ i) {
00282 val[i].ch=Vc[i];} dataType=CAFE_CHAR;};
00283
00284
00285
00286 void set(unsigned int l) {val[0].l= (int) l; dataType=CAFE_LONG;};
00287 void set(unsigned short us) {val[0].us=us; dataType=CAFE_ENUM;};
00288 void set(unsigned char ch) {val[0].ch=ch; dataType=CAFE_CHAR;};
00289 void set(dbr_string_t str) {strcpy(val[0].str,str); dataType=CAFE_STRING;};
00290 void set(std::string str) {strcpy(val[0].str,str.c_str()); dataType=CAFE_STRING;};
00291
00292
00293 void set(double * d) {for (unsigned int i=0; i<nelem; ++ i) {val[i].d=d[i];} dataType=CAFE_DOUBLE;};
00294 void set(float * f) {for (unsigned int i=0; i<nelem; ++ i) {val[i].f=f[i];} dataType=CAFE_FLOAT;};
00295 void set(short * s) {for (unsigned int i=0; i<nelem; ++ i) {val[i].s=s[i];} dataType=CAFE_SHORT;};
00296
00297 void set(long long * ll) {
00298 if ( nelem==1) {
00299 set((long long) ll[0]);
00300 }
00301 else {
00302 for (unsigned int i=0; i<nelem; ++ i) {val[i].d= ll[i];} dataType=CAFE_DOUBLE;
00303 }
00304 };
00305 void set(unsigned long long * ll) {
00306 if ( nelem==1) {
00307 set((unsigned long long) ll[0]);
00308 }
00309 else {
00310 for (unsigned int i=0; i<nelem; ++ i) {val[i].d= ll[i];} dataType=CAFE_DOUBLE;
00311 }
00312 };
00313
00314 void set(int * l) {for (unsigned int i=0; i<nelem; ++ i) {val[i].l=l[i];} dataType=CAFE_LONG;};
00315 void set(unsigned int * l) {for (unsigned int i=0; i<nelem; ++ i)
00316 {val[i].l= (int) l[i];} dataType=CAFE_LONG;};
00317 void set(unsigned short * us) {for (unsigned int i=0; i<nelem; ++ i)
00318 {val[i].us=us[i];} dataType=CAFE_ENUM;};
00319 void set(unsigned char * ch) {for (unsigned int i=0; i<nelem; ++ i)
00320 {val[i].ch=ch[i];} dataType=CAFE_CHAR;};
00321 void set(dbr_string_t * str) {for (unsigned int i=0; i<nelem; ++ i)
00322 {strcpy(val[i].str,str[i]);} dataType=CAFE_STRING;};
00323 void set(std::string * str) {for (unsigned int i=0; i<nelem; ++ i)
00324 {strcpy(val[i].str,str[i].c_str());} dataType=CAFE_STRING;};
00325
00326 std::string concatToString(){
00327 std::string psWF = "";
00328 if (dataTypeNative==CAFE_CHAR) {
00329 for (unsigned int i=0; i<nelem; ++i) {
00330 if (val[i].ch != '\0') {
00331 psWF.append(1, (dbr_char_t) val[i].ch);
00332 }
00333 }
00334 }
00335 return psWF;
00336 }
00337
00338 std::string getWFAsString(){
00339 std::string psWF = "";
00340 if (dataTypeNative==CAFE_CHAR) {
00341 for (unsigned int i=0; i<nelem; ++i) {
00342 if (val[i].ch != '\0') {
00343 psWF.append(1, (dbr_char_t) val[i].ch);
00344 }
00345 }
00346 }
00347 return psWF;
00348 }
00349
00350
00351 double getDouble(unsigned int idx) {return (double) val[idx].d;}
00352 float getFloat (unsigned int idx) {return (float) val[idx].f;}
00353 short getShort (unsigned int idx) {return (short) val[idx].s;}
00354 int getInt (unsigned int idx) {return (int) val[idx].l;}
00355 int getLong (unsigned int idx) {return (int) val[idx].l;}
00356 unsigned short getEnum (unsigned int idx) {return (unsigned short) val[idx].us;}
00357 unsigned short getUShort(unsigned int idx) {return (unsigned short) val[idx].us;}
00358 unsigned char getChar (unsigned int idx) {return (unsigned char ) val[idx].ch;}
00359
00360
00361
00362 dbr_string_t * getString(unsigned int idx) {
00363 #define __METHOD__ "PVHolder::getString "
00364 if (dataType!=CAFE_STRING) {
00365 std::cout << "******* WARNING *******" << std::endl;
00366 std::cout << __METHOD__ << __LINE__ << std::endl;
00367 std::cout << "DataType is " << (cafeDataTypeCode.message((CAFE_DATATYPE)dataType)).c_str() <<
00368 " hence getString method is invalid! " << std::endl;
00369 std::cout << "Use getAsString method if you wish to retrieve the data as a string! " << std::endl;
00370 std::cout << "**********************" << std::endl;
00371
00372 return (dbr_string_t *) "";
00373 }
00374 return (dbr_string_t *) val[idx].str;
00375 #undef __METHOD__
00376 }
00377
00378 boost::shared_ptr<std::vector<double> > getAsVDouble(){
00379 #define __METHOD__ "PVHolder::getAsVDouble "
00380
00381 ValVD_ptr.reset(new std::vector<double>());
00382 ValVD_ptr->reserve(nelem);
00383
00384 switch (dataType)
00385 {
00386 case CAFE_DOUBLE:
00387 for (unsigned i=0; i<nelem; ++i) {ValVD_ptr->push_back(val[i].d);}
00388 break;
00389 case CAFE_FLOAT:
00390 for (unsigned i=0; i<nelem; ++i) {ValVD_ptr->push_back(val[i].f);}
00391 break;
00392 case CAFE_LONG:
00393 for (unsigned i=0; i<nelem; ++i) {ValVD_ptr->push_back(val[i].l);}
00394 break;
00395 case CAFE_SHORT:
00396 for (unsigned i=0; i<nelem; ++i) {ValVD_ptr->push_back(val[i].s);}
00397 break;
00398 case CAFE_ENUM:
00399 for (unsigned i=0; i<nelem; ++i) {ValVD_ptr->push_back(val[i].us);}
00400 break;
00401 case CAFE_CHAR:
00402 for (unsigned i=0; i<nelem; ++i) {ValVD_ptr->push_back(val[i].ch);}
00403 break;
00404 case CAFE_STRING:
00405 default:
00406 for (unsigned i=0; i<nelem; ++i) {ValVD_ptr->push_back( getAsDouble(i));}
00407 break;
00408 }
00409
00410 return ValVD_ptr;
00411 #undef __METHOD__
00412 }
00413
00414 boost::shared_ptr<std::vector<float> > getAsVFloat(){
00415 #define __METHOD__ "PVHolder::getAsVFloat "
00416
00417 ValVF_ptr.reset(new std::vector<float>());
00418 ValVF_ptr->reserve(nelem);
00419
00420 switch (dataType)
00421 {
00422 case CAFE_DOUBLE:
00423 for (unsigned i=0; i<nelem; ++i) {ValVF_ptr->push_back((float) val[i].d);}
00424 break;
00425 case CAFE_FLOAT:
00426 for (unsigned i=0; i<nelem; ++i) {ValVF_ptr->push_back(val[i].f);}
00427 break;
00428 case CAFE_LONG:
00429 for (unsigned i=0; i<nelem; ++i) {ValVF_ptr->push_back(val[i].l);}
00430 break;
00431 case CAFE_SHORT:
00432 for (unsigned i=0; i<nelem; ++i) {ValVF_ptr->push_back(val[i].s);}
00433 break;
00434 case CAFE_ENUM:
00435 for (unsigned i=0; i<nelem; ++i) {ValVF_ptr->push_back(val[i].us);}
00436 break;
00437 case CAFE_CHAR:
00438 for (unsigned i=0; i<nelem; ++i) {ValVF_ptr->push_back(val[i].ch);}
00439 break;
00440 case CAFE_STRING:
00441 default:
00442 for (unsigned i=0; i<nelem; ++i) {ValVD_ptr->push_back( getAsFloat(i));}
00443 break;
00444 }
00445
00446
00447
00448
00449
00450
00451
00452
00453
00454
00455
00456 return ValVF_ptr;
00457 #undef __METHOD__
00458 }
00459
00460
00461 boost::shared_ptr<std::vector<int> > getAsVInt(){
00462 #define __METHOD__ "PVHolder::getAsVInt "
00463
00464 ValVI_ptr.reset(new std::vector<int>());
00465 ValVI_ptr->reserve(nelem);
00466
00467 switch (dataType)
00468 {
00469 case CAFE_DOUBLE:
00470 for (unsigned i=0; i<nelem; ++i) {ValVI_ptr->push_back((int) val[i].d);}
00471 break;
00472 case CAFE_FLOAT:
00473 for (unsigned i=0; i<nelem; ++i) {ValVI_ptr->push_back((int) val[i].f);}
00474 break;
00475 case CAFE_LONG:
00476 for (unsigned i=0; i<nelem; ++i) {ValVI_ptr->push_back(val[i].l);}
00477 break;
00478 case CAFE_SHORT:
00479 for (unsigned i=0; i<nelem; ++i) {ValVI_ptr->push_back(val[i].s);}
00480 break;
00481 case CAFE_ENUM:
00482 for (unsigned i=0; i<nelem; ++i) {ValVI_ptr->push_back(val[i].us);}
00483 break;
00484 case CAFE_CHAR:
00485 for (unsigned i=0; i<nelem; ++i) {ValVI_ptr->push_back(val[i].ch);}
00486 break;
00487 case CAFE_STRING:
00488 default:
00489 for (unsigned i=0; i<nelem; ++i) {ValVI_ptr->push_back( getAsInt(i));}
00490 break;
00491 }
00492
00493 return ValVI_ptr;
00494 #undef __METHOD__
00495 }
00496
00497
00498
00499 boost::shared_ptr<std::vector<long> > getAsVLong(){
00500 #define __METHOD__ "PVHolder::getAsVInt "
00501
00502 ValVL_ptr.reset(new std::vector<long>());
00503 ValVL_ptr->reserve(nelem);
00504
00505 switch (dataType)
00506 {
00507 case CAFE_DOUBLE:
00508 for (unsigned i=0; i<nelem; ++i) {ValVL_ptr->push_back((long) val[i].d);}
00509 break;
00510 case CAFE_FLOAT:
00511 for (unsigned i=0; i<nelem; ++i) {ValVL_ptr->push_back((long) val[i].f);}
00512 break;
00513 case CAFE_LONG:
00514 for (unsigned i=0; i<nelem; ++i) {ValVL_ptr->push_back((long) val[i].l);}
00515 break;
00516 case CAFE_SHORT:
00517 for (unsigned i=0; i<nelem; ++i) {ValVL_ptr->push_back((long) val[i].s);}
00518 break;
00519 case CAFE_ENUM:
00520 for (unsigned i=0; i<nelem; ++i) {ValVL_ptr->push_back((long) val[i].us);}
00521 break;
00522 case CAFE_CHAR:
00523 for (unsigned i=0; i<nelem; ++i) {ValVL_ptr->push_back((long) val[i].ch);}
00524 break;
00525 case CAFE_STRING:
00526 default:
00527 for (unsigned i=0; i<nelem; ++i) {ValVL_ptr->push_back( getAsLong(i));}
00528 break;
00529 }
00530
00531 return ValVL_ptr;
00532 #undef __METHOD__
00533 }
00534
00535
00536 boost::shared_ptr<std::vector<unsigned long> > getAsVULong(){
00537 #define __METHOD__ "PVHolder::getAsVInt "
00538
00539 ValVUL_ptr.reset(new std::vector<unsigned long>());
00540 ValVUL_ptr->reserve(nelem);
00541
00542 switch (dataType)
00543 {
00544 case CAFE_DOUBLE:
00545 for (unsigned i=0; i<nelem; ++i) {ValVUL_ptr->push_back((unsigned long) val[i].d);}
00546 break;
00547 case CAFE_FLOAT:
00548 for (unsigned i=0; i<nelem; ++i) {ValVUL_ptr->push_back((unsigned long) val[i].f);}
00549 break;
00550 case CAFE_LONG:
00551 for (unsigned i=0; i<nelem; ++i) {ValVUL_ptr->push_back((unsigned long) val[i].l);}
00552 break;
00553 case CAFE_SHORT:
00554 for (unsigned i=0; i<nelem; ++i) {ValVUL_ptr->push_back((unsigned long) val[i].s);}
00555 break;
00556 case CAFE_ENUM:
00557 for (unsigned i=0; i<nelem; ++i) {ValVUL_ptr->push_back((unsigned long) val[i].us);}
00558 break;
00559 case CAFE_CHAR:
00560 for (unsigned i=0; i<nelem; ++i) {ValVUL_ptr->push_back((unsigned long) val[i].ch);}
00561 break;
00562 case CAFE_STRING:
00563 default:
00564 for (unsigned i=0; i<nelem; ++i) {ValVUL_ptr->push_back( getAsULong(i));}
00565 break;
00566 }
00567
00568 return ValVUL_ptr;
00569 #undef __METHOD__
00570 }
00571
00572
00573
00574
00575 boost::shared_ptr<std::vector<long long> > getAsVLongLong(){
00576 #define __METHOD__ "PVHolder::getAsVLongLong "
00577
00578 ValVLL_ptr.reset(new std::vector<long long>());
00579 ValVLL_ptr->reserve(nelem);
00580
00581 switch (dataType)
00582 {
00583 case CAFE_DOUBLE:
00584 for (unsigned i=0; i<nelem; ++i) {ValVLL_ptr->push_back((long long) val[i].d);}
00585 break;
00586 case CAFE_FLOAT:
00587 for (unsigned i=0; i<nelem; ++i) {ValVLL_ptr->push_back((long long) val[i].f);}
00588 break;
00589 case CAFE_LONG:
00590 for (unsigned i=0; i<nelem; ++i) {ValVLL_ptr->push_back((long long) val[i].l);}
00591 break;
00592 case CAFE_SHORT:
00593 for (unsigned i=0; i<nelem; ++i) {ValVLL_ptr->push_back((long long) val[i].s);}
00594 break;
00595 case CAFE_ENUM:
00596 for (unsigned i=0; i<nelem; ++i) {ValVLL_ptr->push_back((long long) val[i].us);}
00597 break;
00598 case CAFE_CHAR:
00599 for (unsigned i=0; i<nelem; ++i) {ValVLL_ptr->push_back((long long) val[i].ch);}
00600 break;
00601 case CAFE_STRING:
00602 default:
00603 for (unsigned i=0; i<nelem; ++i) {ValVLL_ptr->push_back( getAsLongLong(i));}
00604 break;
00605 }
00606
00607 return ValVLL_ptr;
00608 #undef __METHOD__
00609 }
00610
00611
00612 boost::shared_ptr<std::vector<unsigned long long> > getAsVULongLong(){
00613 #define __METHOD__ "PVHolder::getAsVLongLong "
00614
00615 ValVULL_ptr.reset(new std::vector<unsigned long long>());
00616 ValVULL_ptr->reserve(nelem);
00617
00618 switch (dataType)
00619 {
00620 case CAFE_DOUBLE:
00621 for (unsigned i=0; i<nelem; ++i) {ValVULL_ptr->push_back((unsigned long long) val[i].d);}
00622 break;
00623 case CAFE_FLOAT:
00624 for (unsigned i=0; i<nelem; ++i) {ValVULL_ptr->push_back((unsigned long long) val[i].f);}
00625 break;
00626 case CAFE_LONG:
00627 for (unsigned i=0; i<nelem; ++i) {ValVULL_ptr->push_back((unsigned long long) val[i].l);}
00628 break;
00629 case CAFE_SHORT:
00630 for (unsigned i=0; i<nelem; ++i) {ValVULL_ptr->push_back((unsigned long long) val[i].s);}
00631 break;
00632 case CAFE_ENUM:
00633 for (unsigned i=0; i<nelem; ++i) {ValVULL_ptr->push_back((unsigned long long) val[i].us);}
00634 break;
00635 case CAFE_CHAR:
00636 for (unsigned i=0; i<nelem; ++i) {ValVULL_ptr->push_back((unsigned long long) val[i].ch);}
00637 break;
00638 case CAFE_STRING:
00639 default:
00640 for (unsigned i=0; i<nelem; ++i) {ValVULL_ptr->push_back( getAsULongLong(i));}
00641 break;
00642 }
00643
00644 return ValVULL_ptr;
00645 #undef __METHOD__
00646 }
00647
00648
00649
00650
00651
00652 boost::shared_ptr<std::vector<short> > getAsVShort(){
00653 #define __METHOD__ "PVHolder::getAsVShort "
00654
00655 ValVS_ptr.reset(new std::vector<short>());
00656 ValVS_ptr->reserve(nelem);
00657
00658 switch (dataType)
00659 {
00660 case CAFE_DOUBLE:
00661 for (unsigned i=0; i<nelem; ++i) {ValVS_ptr->push_back((short) val[i].d);}
00662 break;
00663 case CAFE_FLOAT:
00664 for (unsigned i=0; i<nelem; ++i) {ValVS_ptr->push_back((short) val[i].f);}
00665 break;
00666 case CAFE_LONG:
00667 for (unsigned i=0; i<nelem; ++i) {ValVS_ptr->push_back((short) val[i].l);}
00668 break;
00669 case CAFE_SHORT:
00670 for (unsigned i=0; i<nelem; ++i) {ValVS_ptr->push_back(val[i].s);}
00671 break;
00672 case CAFE_ENUM:
00673 for (unsigned i=0; i<nelem; ++i) {ValVS_ptr->push_back((short) val[i].us);}
00674 break;
00675 case CAFE_CHAR:
00676 for (unsigned i=0; i<nelem; ++i) {ValVS_ptr->push_back((unsigned short) val[i].ch);}
00677 break;
00678 case CAFE_STRING:
00679 default:
00680 for (unsigned i=0; i<nelem; ++i) {ValVS_ptr->push_back( getAsShort(i));}
00681 break;
00682 }
00683
00684 return ValVS_ptr;
00685 #undef __METHOD__
00686 }
00687
00688
00689
00690 boost::shared_ptr<std::vector<unsigned short> > getAsVUShort(){
00691 #define __METHOD__ "PVHolder::getAsVUShort "
00692
00693 ValVUS_ptr.reset(new std::vector<unsigned short>());
00694 ValVUS_ptr->reserve(nelem);
00695
00696 switch (dataType)
00697 {
00698 case CAFE_DOUBLE:
00699 for (unsigned i=0; i<nelem; ++i) {ValVUS_ptr->push_back((unsigned short) val[i].d);}
00700 break;
00701 case CAFE_FLOAT:
00702 for (unsigned i=0; i<nelem; ++i) {ValVUS_ptr->push_back((unsigned short) val[i].f);}
00703 break;
00704 case CAFE_LONG:
00705 for (unsigned i=0; i<nelem; ++i) {ValVUS_ptr->push_back((unsigned short) val[i].l);}
00706 break;
00707 case CAFE_SHORT:
00708 for (unsigned i=0; i<nelem; ++i) {ValVUS_ptr->push_back((unsigned short)val[i].s);}
00709 break;
00710 case CAFE_ENUM:
00711 for (unsigned i=0; i<nelem; ++i) {ValVUS_ptr->push_back( val[i].us);}
00712 break;
00713 case CAFE_CHAR:
00714 for (unsigned i=0; i<nelem; ++i) {ValVUS_ptr->push_back((unsigned short) val[i].ch);}
00715 break;
00716 case CAFE_STRING:
00717 default:
00718 for (unsigned i=0; i<nelem; ++i) {ValVUS_ptr->push_back( getAsUShort(i));}
00719 break;
00720 }
00721
00722 return ValVUS_ptr;
00723 #undef __METHOD__
00724 }
00725
00726
00727 boost::shared_ptr<std::vector<unsigned char> > getAsVUChar(){
00728 #define __METHOD__ "PVHolder::getAsVUChar "
00729
00730 ValVC_ptr.reset(new std::vector<unsigned char>());
00731 ValVC_ptr->reserve(nelem);
00732
00733 switch (dataType)
00734 {
00735 case CAFE_DOUBLE:
00736 for (unsigned i=0; i<nelem; ++i) {ValVC_ptr->push_back((unsigned char) val[i].d);}
00737 break;
00738 case CAFE_FLOAT:
00739 for (unsigned i=0; i<nelem; ++i) {ValVC_ptr->push_back((unsigned char) val[i].f);}
00740 break;
00741 case CAFE_LONG:
00742 for (unsigned i=0; i<nelem; ++i) {ValVC_ptr->push_back((unsigned char) val[i].l);}
00743 break;
00744 case CAFE_SHORT:
00745 for (unsigned i=0; i<nelem; ++i) {ValVC_ptr->push_back((unsigned char)val[i].s);}
00746 break;
00747 case CAFE_ENUM:
00748 for (unsigned i=0; i<nelem; ++i) {ValVC_ptr->push_back( (unsigned char)val[i].us);}
00749 break;
00750 case CAFE_CHAR:
00751 for (unsigned i=0; i<nelem; ++i) {ValVC_ptr->push_back((unsigned char) val[i].ch);}
00752 break;
00753 case CAFE_STRING:
00754 default:
00755 for (unsigned i=0; i<nelem; ++i) {ValVC_ptr->push_back( (unsigned char) getAsChar(i));}
00756 break;
00757 }
00758
00759 return ValVC_ptr;
00760 #undef __METHOD__
00761 }
00762
00763 boost::shared_ptr<std::vector<std::string> > getAsVString(){
00764 #define __METHOD__ "PVHolder::getAsVString "
00765
00766 ValVStr_ptr.reset(new std::vector<std::string>());
00767 ValVStr_ptr->reserve(nelem);
00768 for (unsigned i=0; i<nelem; ++i) {ValVStr_ptr->push_back( getAsString(i));}
00769
00770 return ValVStr_ptr;
00771 #undef __METHOD__
00772 }
00773
00774
00775
00776 std::vector<std::string> getAsVectorString() {
00777 boost::shared_ptr<std::vector<std::string> > spVs = getAsVString();
00778 return *spVs.get();
00779 }
00780 std::vector<float> getAsVectorFloat() {
00781 boost::shared_ptr<std::vector<float> > spVf = getAsVFloat();
00782 return *spVf.get();
00783 }
00784 std::vector<double> getAsVectorDouble() {
00785 boost::shared_ptr<std::vector<double> > spVd = getAsVDouble();
00786 return *spVd.get();
00787 }
00788 std::vector<int> getAsVectorInt() {
00789 boost::shared_ptr<std::vector<int> > spVi = getAsVInt();
00790 return *spVi.get();
00791 }
00792
00793 std::vector<long> getAsVectorLong() {
00794 boost::shared_ptr<std::vector<long> > spVl = getAsVLong();
00795 return *spVl.get();
00796 }
00797
00798 std::vector<unsigned long> getAsVectorULong() {
00799 boost::shared_ptr<std::vector<unsigned long> > spVul = getAsVULong();
00800 return *spVul.get();
00801 }
00802
00803 std::vector<long long> getAsVectorLongLong() {
00804 boost::shared_ptr<std::vector<long long> > spVll = getAsVLongLong();
00805 return *spVll.get();
00806 }
00807
00808 std::vector<unsigned long long> getAsVectorULongLong() {
00809 boost::shared_ptr<std::vector<unsigned long long> > spVull = getAsVULongLong();
00810 return *spVull.get();
00811 }
00812
00813
00814 std::vector<short> getAsVectorShort() {
00815 boost::shared_ptr<std::vector<short> > spVsh = getAsVShort();
00816 return *spVsh.get();
00817 }
00818
00819 std::vector<unsigned short> getAsVectorUShort() {
00820 boost::shared_ptr<std::vector<unsigned short> > spVus = getAsVUShort();
00821 return *spVus.get();
00822 }
00823 std::vector<unsigned char> getAsVectorUChar() {
00824 boost::shared_ptr<std::vector<unsigned char> > spVc = getAsVUChar();
00825 return *spVc.get();
00826 }
00827
00828
00829 ValDPtr getDouble(){
00830 #define __METHOD__ "PVHolder::getDouble "
00831 if (dataType!=CAFE_DOUBLE) {
00832 std::cout << "******* WARNING *******" << std::endl;
00833 std::cout << __METHOD__ << __LINE__ << std::endl;
00834 std::cout << "DataType is " << (cafeDataTypeCode.message((CAFE_DATATYPE)dataType)).c_str() <<
00835 " hence getDouble method is invalid! " << std::endl;
00836 std::cout << "Use getAsDouble method if you wish to retrieve the data as a double! " << std::endl;
00837 std::cout << "**********************" << std::endl;
00838 }
00839
00840 ValD_ptr.reset(new double[nelem]);
00841
00842 for (unsigned i=0; i<nelem; ++i) {
00843 ValD_ptr[i] = val[i].d;
00844 }
00845
00846 return ValD_ptr;
00847 #undef __METHOD__
00848 }
00849
00850 ValFPtr getFloat() {
00851 #define __METHOD__ "PVHolder::getFloat "
00852 if (dataType!=CAFE_FLOAT) {
00853 std::cout << "******* WARNING *******" << std::endl;
00854 std::cout << __METHOD__ << __LINE__ << std::endl;
00855 std::cout << "DataType is " << (cafeDataTypeCode.message((CAFE_DATATYPE)dataType)).c_str() <<
00856 " hence getFloat method is invalid! " << std::endl;
00857 std::cout << "Use getAsFloat method if you wish to retrieve the data as a float! " << std::endl;
00858 std::cout << "**********************" << std::endl;
00859 }
00860 ValF_ptr.reset(new float[nelem]);
00861 for (unsigned i=0; i<nelem; ++i) {
00862 ValF_ptr[i] = val[i].f;
00863 }
00864 return ValF_ptr;
00865
00866 #undef __METHOD__
00867 }
00868
00869 ValSPtr getShort() {
00870 #define __METHOD__ "PVHolder::getShort "
00871 if (dataType==CAFE_SHORT) {
00872 std::cout << "******* WARNING *******" << std::endl;
00873 std::cout << __METHOD__ << __LINE__ << std::endl;
00874 std::cout << "DataType is " << (cafeDataTypeCode.message((CAFE_DATATYPE)dataType)).c_str() <<
00875 " hence getShort method is invalid! " << std::endl;
00876 std::cout << "Use getAsShort method if you wish to retrieve the data as a short! " << std::endl;
00877 std::cout << "**********************" << std::endl;
00878 }
00879 ValS_ptr.reset(new short[nelem]);
00880 for (unsigned i=0; i<nelem; ++i) {
00881 ValS_ptr[i] = val[i].s;
00882 }
00883 return ValS_ptr;
00884
00885 #undef __METHOD__
00886 }
00887
00888 ValIPtr getInt(){
00889 #define __METHOD__ "PVHolder::getInt (meaning dbr_long_t) "
00890 if (dataType!=CAFE_LONG) {
00891 std::cout << "******* WARNING *******" << std::endl;
00892 std::cout << __METHOD__ << __LINE__ << std::endl;
00893 std::cout << "DataType is " << (cafeDataTypeCode.message((CAFE_DATATYPE)dataType)).c_str() <<
00894 " hence getInt method is invalid! " << std::endl;
00895 std::cout << "Use getAsInt method if you wish to retrieve the data as a int! " << std::endl;
00896 std::cout << "**********************" << std::endl;
00897 }
00898 ValI_ptr.reset(new int[nelem]);
00899 for (unsigned i=0; i<nelem; ++i) {
00900 ValI_ptr[i] = val[i].l;
00901 }
00902 return ValI_ptr;
00903 #undef __METHOD__
00904 }
00905
00906 ValIPtr getLong(){
00907 #define __METHOD__ "PVHolder::getLong (meaning dbr_long_t) "
00908 if (dataType!=CAFE_LONG) {
00909 std::cout << "******* WARNING *******" << std::endl;
00910 std::cout << __METHOD__ << __LINE__ << std::endl;
00911 std::cout << "DataType is " << (cafeDataTypeCode.message((CAFE_DATATYPE)dataType)).c_str() <<
00912 " hence getLong method is invalid! " << std::endl;
00913 std::cout << "Use getAsLong method if you wish to retrieve the data as a dbr_long_t! " << std::endl;
00914 std::cout << "**********************" << std::endl;
00915 }
00916 ValI_ptr.reset(new int[nelem]);
00917 for (unsigned i=0; i<nelem; ++i) {
00918 ValI_ptr[i] = val[i].l;
00919 }
00920 return ValI_ptr;
00921 #undef __METHOD__
00922 }
00923
00924 ValUSPtr getEnum(){
00925 #define __METHOD__ "PVHolder::getEnum "
00926 if (dataType!=CAFE_ENUM) {
00927 std::cout << "******* WARNING *******" << std::endl;
00928 std::cout << __METHOD__ << __LINE__ << std::endl;
00929 std::cout << "DataType is " << (cafeDataTypeCode.message((CAFE_DATATYPE)dataType)).c_str() <<
00930 " hence getEnum method is invalid! " << std::endl;
00931 std::cout << "Use getAsEnum method if you wish to retrieve the data as an enum (unsigned short)! " << std::endl;
00932 std::cout << "**********************" << std::endl;
00933 }
00934 ValUS_ptr.reset(new unsigned short[nelem]);
00935 for (unsigned i=0; i<nelem; ++i) {
00936 ValUS_ptr[i] = val[i].us;
00937 }
00938 return ValUS_ptr;
00939 #undef __METHOD__
00940 }
00941
00942 ValUSPtr getUShort(){
00943 #define __METHOD__ "PVHolder::getUShort "
00944 if (dataType!=CAFE_USHORT) {
00945 std::cout << "******* WARNING *******" << std::endl;
00946 std::cout << __METHOD__ << __LINE__ << std::endl;
00947 std::cout << "DataType is " << (cafeDataTypeCode.message((CAFE_DATATYPE)dataType)).c_str() <<
00948 " hence getUShort method is invalid! " << std::endl;
00949 std::cout << "Use getAsUSHort method if you wish to retrieve the data as an unsigned short! " << std::endl;
00950 std::cout << "**********************" << std::endl;
00951 }
00952 ValUS_ptr.reset(new unsigned short[nelem]);
00953 for (unsigned i=0; i<nelem; ++i) {
00954 ValUS_ptr[i] = val[i].us;
00955 }
00956 return ValUS_ptr;
00957 #undef __METHOD__
00958 }
00959
00960 ValChPtr getChar(){
00961 #define __METHOD__ "PVHolder::getChar "
00962 if (dataType!=CAFE_CHAR) {
00963 std::cout << "******* WARNING *******" << std::endl;
00964 std::cout << __METHOD__ << __LINE__ << std::endl;
00965 std::cout << "DataType is " << (cafeDataTypeCode.message((CAFE_DATATYPE)dataType)).c_str() <<
00966 " hence getChar method is invalid! " << std::endl;
00967 std::cout << "Use getAsChar method if you wish to retrieve the data as a char! " << std::endl;
00968 std::cout << "**********************" << std::endl;
00969 }
00970 ValCh_ptr.reset(new unsigned char[nelem]);
00971 for (unsigned i=0; i<nelem; ++i) {
00972 ValCh_ptr[i] = val[i].ch;
00973 }
00974 return ValCh_ptr;
00975 #undef __METHOD__
00976 }
00977
00978 ValStrPtr getString() {
00979 #define __METHOD__ "PVHolder::getString "
00980 if (dataType!=CAFE_STRING) {
00981 std::cout << "******* WARNING *******" << std::endl;
00982 std::cout << __METHOD__ << __LINE__ << std::endl;
00983 std::cout << "DataType is " << (cafeDataTypeCode.message((CAFE_DATATYPE)dataType)).c_str() <<
00984 " hence getString method is invalid! " << std::endl;
00985 std::cout << "Use getAsString method if you wish to retrieve the data as a string! " << std::endl;
00986 std::cout << "**********************" << std::endl;
00987
00988 }
00989 ValStr_ptr.reset(new dbr_string_t[nelem]);
00990 for (unsigned i=0; i<nelem; ++i) {
00991 strcpy(ValStr_ptr[i] , val[i].str);
00992 }
00993 return ValStr_ptr;
00994 #undef __METHOD__
00995 }
00996
00997 double getAsDouble () {
00998 return (double) renderDouble.get(0, dataType, val.get())[0];
00999 }
01000
01001 double getAsDouble(unsigned int idx) throw(std::out_of_range){
01002 if(isIndexOutOfRange(idx)) {
01003 std::ostringstream oss;
01004 oss << "Exception! Index " << idx
01005 << " to PVHolder method is out of range. Valid range is from 0 to " << size-1;
01006 throw std::out_of_range(oss.str());
01007 }
01008 return (double) renderDouble.get(idx, dataType, val.get())[0];
01009 }
01010
01011 float getAsFloat () {
01012 return (float) renderFloat.get(0, dataType, val.get())[0];
01013 }
01014
01015 float getAsFloat(unsigned int idx) throw(std::out_of_range){
01016 if(isIndexOutOfRange(idx)) {
01017 std::ostringstream oss;
01018 oss << "Exception! Index " << idx
01019 << " to PVHolder method is out of range. Valid range is from 0 to " << size-1;
01020 throw std::out_of_range(oss.str());
01021 }
01022 return (float) renderFloat.get(idx, dataType, val.get())[0];
01023 }
01024
01025 short getAsShort () {
01026 return (short) renderShort.get(0, dataType, val.get())[0];
01027 }
01028
01029 short getAsShort(unsigned int idx) throw(std::out_of_range){
01030 if(isIndexOutOfRange(idx)) {
01031 std::ostringstream oss;
01032 oss << "Exception! Index " << idx
01033 << " to PVHolder method is out of range. Valid range is from 0 to " << size-1;
01034 throw std::out_of_range(oss.str());
01035 }
01036 return (short) renderShort.get(idx, dataType, val.get())[0];
01037 }
01038
01039 int getAsLong () {
01040 return (int) renderLong.get(0, dataType, val.get())[0];
01041 }
01042
01043 int getAsLong(unsigned int idx) throw(std::out_of_range){
01044 if(isIndexOutOfRange(idx)) {
01045 std::ostringstream oss;
01046 oss << "Exception! Index " << idx
01047 << " to PVHolder method is out of range. Valid range is from 0 to " << size-1;
01048 throw std::out_of_range(oss.str());
01049 }
01050 return (int) renderLong.get(idx, dataType, val.get())[0];
01051 }
01052
01053 unsigned short getAsEnum () {
01054 return (unsigned short) renderEnum.get(0, dataType, val.get())[0];
01055 }
01056
01057 unsigned short getAsEnum(unsigned int idx) throw(std::out_of_range){
01058 if(isIndexOutOfRange(idx)) {
01059 std::ostringstream oss;
01060 oss << "Exception! Index " << idx
01061 << " to PVHolder method is out of range. Valid range is from 0 to " << size-1;
01062 throw std::out_of_range(oss.str());
01063 }
01064 return (unsigned short) renderEnum.get(idx, dataType, val.get())[0];
01065 }
01066
01067 unsigned short getAsUShort () {
01068 return (unsigned short) renderEnum.get(0, dataType, val.get())[0];
01069 }
01070
01071 unsigned short getAsUShort(unsigned int idx) throw(std::out_of_range){
01072 if(isIndexOutOfRange(idx)) {
01073 std::ostringstream oss;
01074 oss << "Exception! Index " << idx
01075 << " to PVHolder method is out of range. Valid range is from 0 to " << size-1;
01076 throw std::out_of_range(oss.str());
01077 }
01078 return (unsigned short) renderEnum.get(idx, dataType, val.get())[0];
01079 }
01080
01081 unsigned char getAsChar () {
01082 return (char) renderChar.get(0, dataType, val.get())[0];
01083 }
01084
01085 unsigned char getAsChar(unsigned int idx) throw(std::out_of_range){
01086 if(isIndexOutOfRange(idx)) {
01087 std::ostringstream oss;
01088 oss << "Exception! Index " << idx
01089 << " to PVHolder method is out of range. Valid range is from 0 to " << size-1;
01090 throw std::out_of_range(oss.str());
01091 }
01092 return (char) renderChar.get(idx, dataType, val.get())[0];
01093 }
01094
01095 unsigned char getAsUChar () {
01096 return (unsigned char) renderUChar.get(0, dataType, val.get())[0];
01097 }
01098
01099 unsigned char getAsUChar(unsigned int idx) throw(std::out_of_range){
01100 if(isIndexOutOfRange(idx)) {
01101 std::ostringstream oss;
01102 oss << "Exception! Index " << idx
01103 << " to PVHolder method is out of range. Valid range is from 0 to " << size-1;
01104 throw std::out_of_range(oss.str());
01105 }
01106 return (unsigned char) renderUChar.get(idx, dataType, val.get())[0];
01107 }
01108
01109 unsigned int getAsULong () {
01110 return (unsigned int) renderULong.get(0, dataType, val.get())[0];
01111 }
01112
01113 unsigned int getAsULong(unsigned int idx) throw(std::out_of_range){
01114 if(isIndexOutOfRange(idx)) {
01115 std::ostringstream oss;
01116 oss << "Exception! Index " << idx
01117 << " to PVHolder method is out of range. Valid range is from 0 to " << size-1;
01118 throw std::out_of_range(oss.str());
01119 }
01120 return (unsigned int) renderULong.get(idx, dataType, val.get())[0];
01121 }
01122
01123 long long getAsLongLong () {
01124 return (long long) renderLongLong.get(0, dataType, val.get())[0];
01125 }
01126
01127 long long getAsLongLong(unsigned int idx) throw(std::out_of_range){
01128 if(isIndexOutOfRange(idx)) {
01129 std::ostringstream oss;
01130 oss << "Exception! Index " << idx
01131 << " to PVHolder method is out of range. Valid range is from 0 to " << size-1;
01132 throw std::out_of_range(oss.str());
01133 }
01134 return (long long) renderLongLong.get(idx, dataType, val.get())[0];
01135 }
01136
01137 unsigned long long getAsULongLong () {
01138 return (unsigned long long) renderULongLong.get(0, dataType, val.get())[0];
01139 }
01140
01141 unsigned long long getAsULongLong(unsigned int idx) throw(std::out_of_range){
01142 if(isIndexOutOfRange(idx)) {
01143 std::ostringstream oss;
01144 oss << "Exception! Index " << idx
01145 << " to PVHolder method is out of range. Valid range is from 0 to " << size-1;
01146 throw std::out_of_range(oss.str());
01147 }
01148 return (unsigned long long) renderULongLong.get(idx, dataType, val.get())[0];
01149 }
01150
01151 int getAsInt () {
01152 return (int) renderInt.get(0, dataType, val.get())[0];
01153 }
01154
01155 int getAsInt(unsigned int idx) throw(std::out_of_range){
01156 if(isIndexOutOfRange(idx)) {
01157 std::ostringstream oss;
01158 oss << "Exception! Index " << idx
01159 << " to PVHolder method is out of range. Valid range is from 0 to " << size-1;
01160 throw std::out_of_range(oss.str());
01161 }
01162 return (int) renderInt.get(idx, dataType, val.get())[0];
01163 }
01164
01165 unsigned int getAsUInt () {
01166 return (unsigned int) renderInt.get(0, dataType, val.get())[0];
01167 }
01168
01169 unsigned int getAsUInt(unsigned int idx) throw(std::out_of_range){
01170 if(isIndexOutOfRange(idx)) {
01171 std::ostringstream oss;
01172 oss << "Exception! Index " << idx
01173 << " to PVHolder method is out of range. Valid range is from 0 to " << size-1;
01174 throw std::out_of_range(oss.str());
01175 }
01176 return (unsigned int) renderInt.get(idx, dataType, val.get())[0];
01177 }
01178
01179
01180 std::string getEnumIntegerValueAsString() {
01181 #define __METHOD__ "PVHolder::getEnumIntegerValueAsString"
01182 if (dataType!=CAFE_ENUM) {
01183 std::cout << "******* WARNING *******" << std::endl;
01184 std::cout << __METHOD__ << __LINE__ << std::endl;
01185 std::cout << "DataType is " << (cafeDataTypeCode.message((CAFE_DATATYPE)dataType)).c_str() <<
01186 " hence getEnumIntegerValueAsString method is invalid! " << std::endl;
01187 std::cout << "Use getAsString method if you want the string equilavent of the ENUM value!" << std::endl;
01188 std::cout << "**********************" << std::endl;
01189 }
01190 return (std::string) renderString.getString(0, dataType, val.get())[0];
01191 #undef __METHOD__
01192 }
01193
01194 std::string getAsString() {
01195 if(dataTypeNative==DBR_ENUM && dataType==DBR_ENUM) {
01196
01197 return (std::string) renderString.getStringFromEnum(0, noStr, val.get(), strs)[0];
01198 }
01199 else {
01200 return (std::string) renderString.getString(0, dataType, val.get())[0];
01201 }
01202 }
01203
01204 std::string getAsString(unsigned int idx) throw(std::out_of_range){
01205 if(isIndexOutOfRange(idx)) {
01206 std::ostringstream oss;
01207 oss << "Exception! Index " << idx
01208 << " to PVHolder method is out of range. Valid range is from 0 to " << size-1;
01209 throw std::out_of_range(oss.str());
01210 }
01211 if(dataTypeNative==DBR_ENUM && dataType==CAFE_ENUM) {
01212 return (std::string) renderString.getStringFromEnum(idx, noStr, val.get(), strs)[0];
01213 }
01214 else {
01215 return (std::string) renderString.getString(idx, dataType, val.get())[0];
01216 }
01217 }
01218
01219
01220 char * getAsDbr_string_t() {
01221 if(dataTypeNative==DBR_ENUM && dataType==CAFE_ENUM) {
01222 return (char *) renderString.getStringFromEnum(0, noStr, val.get(), strs)[0];
01223
01224 }
01225 else {
01226 return (char *) renderString.getString(0, dataType, val.get())[0];
01227 }
01228 }
01229
01230
01231 char * getAsDbr_string_t(unsigned int idx) throw(std::out_of_range){
01232 if(isIndexOutOfRange(idx)) {
01233 std::ostringstream oss;
01234 oss << "Exception! Index " << idx
01235 << " to PVHolder method is out of range. Valid range is from 0 to " << size-1;
01236 throw std::out_of_range(oss.str());
01237 }
01238 if(dataTypeNative==DBR_ENUM && dataType==CAFE_ENUM) {
01239 return (char *) renderString.getStringFromEnum(idx, noStr, val.get(), strs)[0];
01240 }
01241 else {
01242 return (char *) renderString.getString(idx, dataType, val.get())[0];
01243 }
01244 }
01245
01246
01247
01248
01249
01250
01251
01252
01253
01254
01255
01256
01257
01258
01259
01260
01261
01262
01263
01264 double getAsDouble(CAFE_DATATYPE_UNION cdu) {
01265 return (double) renderDouble.get(0, dataType, &cdu)[0];
01266 }
01267
01268 float getAsFloat(CAFE_DATATYPE_UNION cdu) {
01269 return (float) renderFloat.get(0, dataType, &cdu)[0];
01270 }
01271
01272 short getAsShort(CAFE_DATATYPE_UNION cdu) {
01273 return (short) renderShort.get(0, dataType, &cdu)[0];
01274 }
01275
01276 int getAsLong(CAFE_DATATYPE_UNION cdu) {
01277 return (int) renderLong.get(0, dataType, &cdu)[0];
01278 }
01279
01280 unsigned short getAsEnum(CAFE_DATATYPE_UNION cdu) {
01281 return (unsigned short) renderEnum.get(0, dataType, &cdu)[0];
01282 }
01283
01284 unsigned short getAsUShort(CAFE_DATATYPE_UNION cdu) {
01285 return (unsigned short) renderEnum.get(0, dataType, &cdu)[0];
01286 }
01287
01288 char getAsChar(CAFE_DATATYPE_UNION cdu) {
01289 char * ans = renderChar.get(0, dataType, &cdu);
01290 return (char ) ans[0];
01291 }
01292 unsigned char getAsUChar(CAFE_DATATYPE_UNION cdu) {
01293 unsigned char * ans = renderUChar.get(0, dataType, &cdu);
01294 return (unsigned char ) ans[0];
01295 }
01296
01297 std::string getAsString(CAFE_DATATYPE_UNION cdu) {
01298 return (std::string) renderString.getString(dataType, cdu)[0];
01299 }
01300
01301 char * getAsDbr_string_t(CAFE_DATATYPE_UNION cdu) {
01302 return (char *) renderString.getString(0, dataType, &cdu)[0];
01303 }
01304 };
01305
01306
01307 #endif //PVHOLDER_H
