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 unsigned int userNo;
00052
00053 unsigned int beamEventNo;
00054
00055 bool rule;
00056 bool hasAlarm;
00057 int status;
00058
00059 short noStr;
00060 char strs [MAX_ENUM_STATES][MAX_ENUM_STRING_SIZE];
00061
00062 CAFEConvert<double> renderDouble;
00063 CAFEConvert<float> renderFloat;
00064 CAFEConvert<short> renderShort;
00065 CAFEConvert<int> renderLong;
00066 CAFEConvert<unsigned short> renderEnum;
00067 CAFEConvert<unsigned char> renderUChar;
00068 CAFEConvert<dbr_string_t> renderString;
00069
00070 CAFEConvert<char> renderChar;
00071 CAFEConvert<unsigned int> renderULong;
00072 CAFEConvert<long long> renderLongLong;
00073 CAFEConvert<unsigned long long> renderULongLong;
00074
00075 CAFEConvert<int> renderInt;
00076 CAFEConvert<unsigned int> renderUInt;
00077
00078
00079 void verifyIndex(unsigned int idx) {
00080 if(idx >= size) {
00081 std::ostringstream oss;
00082 oss << "Exception! Index " << idx
00083 << " to PVHolder method is out of range. Valid range is from 0 to " << size-1;
00084 throw std::out_of_range(oss.str());
00085 }
00086 };
00087
00088 bool isIndexOutOfRange (unsigned int idx) {
00089 return (idx >= size) ? true:false;
00090 };
00091
00092
00093 public:
00094
00095 typedef boost::shared_ptr<CAFE_DATATYPE_UNION []> ValPtr;
00096
00097 ValPtr val;
00098
00099 boost::shared_ptr<vector<double> > ValVD_ptr;
00100 boost::shared_ptr<vector<float> > ValVF_ptr;
00101
00102 boost::shared_ptr<vector<int> > ValVI_ptr;
00103
00104
00105 boost::shared_ptr<vector<string> > ValVStr_ptr;
00106
00107 typedef boost::shared_ptr<double []> ValDPtr;
00108 typedef boost::shared_ptr<float []> ValFPtr;
00109 typedef boost::shared_ptr<short []> ValSPtr;
00110 typedef boost::shared_ptr<int []> ValIPtr;
00111 typedef boost::shared_ptr<unsigned char []> ValChPtr;
00112 typedef boost::shared_ptr<unsigned short []> ValUSPtr;
00113 typedef boost::shared_ptr<dbr_string_t []> ValStrPtr;
00114
00115 ValDPtr ValD_ptr;
00116 ValFPtr ValF_ptr;
00117 ValSPtr ValS_ptr;
00118 ValIPtr ValI_ptr;
00119 ValChPtr ValCh_ptr;
00120 ValUSPtr ValUS_ptr;
00121 ValStrPtr ValStr_ptr;
00122
00123 void setUserNo(unsigned int un) {
00124 userNo=un;
00125 return;
00126 }
00127
00128 unsigned int getUserNo() {
00129 return userNo;
00130 }
00131
00132
00133 void setRule(bool r) {
00134 rule=r;
00135 return;
00136 };
00137
00138
00139
00140 const char * getPV() const {return pv;};
00141 const char * getPVName() const {return pv;};
00142 const char * getPVAlias() const {return pvAlias;};
00143 const char * getDevice() const {return device;};
00144 const char * getAttribute() const {return attrib;};
00145 unsigned int getNelem() const {return nelem;};
00146
00147 const unsigned int getSize() const {return size;};
00148 CAFE_DATATYPE_UNION_SEQ getVal() const {return val.get();};
00149
00150
00151 short getAlarmStatus() const {return alarmStatus;};
00152 short getAlarmSeverity() const {return alarmSeverity;};
00153
00154 unsigned int getBeamEventNo() const {return beamEventNo;};
00155 bool getRule() const {return rule;};
00156 bool getHasAlarm() const{return hasAlarm;};
00157 int getStatus() const {return status;};
00158 CAFE_DATATYPE getDataTypeClient() const {return dataType;};
00159 CAFE_DATATYPE getDataType() const {return dataType;};
00160
00161 CAFEStatusCode getStatusCode() const {return cafeStatusCode;};
00162
00163 short getNoEnumStrings () const {return noStr;};
00164 char * getEnumString(short indx) const {return (char *) strs[indx]; }
00165
00166 void setDataType(CAFE_DATATYPE cdt){
00167 if (cdt > CAFE_DOUBLE || cdt < CAFE_STRING) {
00168 cout << "WARNING: INPUT VALUE NOT A VALID CAFE DATATYPE " << endl;
00169 return;
00170 } else {dataType=cdt; return;}};
00171
00172 void set(double d) {val[0].d=d; dataType=CAFE_DOUBLE;};
00173 void set(float f) {val[0].f=f; dataType=CAFE_FLOAT;};
00174 void set(short s) {val[0].s=s; dataType=CAFE_SHORT;};
00175 void set(long long l) {
00176 if (l > std::numeric_limits<dbr_long_t>::max()) {
00177 cout << "WARNING: INPUT VALUE GREATER THAN MAX LIMIT OF dbr_long_t " << endl;
00178 cout << "TYPE CASTING TO DOUBLE! " << endl;
00179 val[0].d= (double) l; dataType=CAFE_DOUBLE;}
00180 else {
00181 val[0].l= (int) l; dataType=CAFE_LONG;};
00182 }
00183 void set(int l) {val[0].l=l; dataType=CAFE_LONG;};
00184 void set(unsigned long long l) {
00185 if (l > (unsigned long long) std::numeric_limits<dbr_long_t>::max()) {
00186 cout << "WARNING: INPUT VALUE GREATER THAN MAX LIMIT OF dbr_long_t " << endl;
00187 cout << "TYPE CASTING TO DOUBLE! " << endl;
00188 val[0].d= (double) l; dataType=CAFE_DOUBLE;}
00189 else {
00190 val[0].l= (int) l; dataType=CAFE_LONG;};
00191 }
00192
00193
00194 void setString(std::string str) {strcpy(val[0].str,str.c_str()); dataType=CAFE_STRING;};
00195 void setDouble(double d) {val[0].d=d; dataType=CAFE_DOUBLE;};
00196 void setInt(int l) {val[0].l=l; dataType=CAFE_LONG;};
00197 void setVString(vector<std::string> Vstr) {
00198 if(Vstr.size()!=nelem) {nelem=Vstr.size();}
00199 for (unsigned int i=0; i<nelem; ++ i) {
00200 strcpy(val[i].str,Vstr[i].c_str());} dataType=CAFE_STRING;};
00201 void setVDouble(vector<double> Vd) {
00202 if(Vd.size()!=nelem) {nelem=Vd.size();}
00203 for (unsigned int i=0; i<nelem; ++ i) {
00204 val[i].d=Vd[i];} dataType=CAFE_DOUBLE;};
00205 void setVInt (vector<int> Vl) {
00206 if(Vl.size()!=nelem) {nelem=Vl.size();}
00207 for (unsigned int i=0; i<nelem; ++ i) {
00208 val[i].l=Vl[i];} dataType=CAFE_LONG;};
00209
00210 void set(unsigned int l) {val[0].l= (int) l; dataType=CAFE_LONG;};
00211 void set(unsigned short us) {val[0].us=us; dataType=CAFE_ENUM;};
00212 void set(unsigned char ch) {val[0].ch=ch; dataType=CAFE_CHAR;};
00213 void set(dbr_string_t str) {strcpy(val[0].str,str); dataType=CAFE_STRING;};
00214 void set(std::string str) {strcpy(val[0].str,str.c_str()); dataType=CAFE_STRING;};
00215
00216
00217 void set(double * d) {for (unsigned int i=0; i<nelem; ++ i) {val[i].d=d[i];} dataType=CAFE_DOUBLE;};
00218 void set(float * f) {for (unsigned int i=0; i<nelem; ++ i) {val[i].f=f[i];} dataType=CAFE_FLOAT;};
00219 void set(short * s) {for (unsigned int i=0; i<nelem; ++ i) {val[i].s=s[i];} dataType=CAFE_SHORT;};
00220
00221 void set(long long * l) {
00222 for (unsigned int i=0; i<nelem; ++ i) {val[i].l=(int)l[i];} dataType=CAFE_LONG;
00223 };
00224
00225 void set(int * l) {for (unsigned int i=0; i<nelem; ++ i) {val[i].l=l[i];} dataType=CAFE_LONG;};
00226 void set(unsigned int * l) {for (unsigned int i=0; i<nelem; ++ i)
00227 {val[i].l= (int) l[i];} dataType=CAFE_LONG;};
00228 void set(unsigned short * us) {for (unsigned int i=0; i<nelem; ++ i)
00229 {val[i].us=us[i];} dataType=CAFE_ENUM;};
00230 void set(unsigned char * ch) {for (unsigned int i=0; i<nelem; ++ i)
00231 {val[i].ch=ch[i];} dataType=CAFE_CHAR;};
00232 void set(dbr_string_t * str) {for (unsigned int i=0; i<nelem; ++ i)
00233 {strcpy(val[i].str,str[i]);} dataType=CAFE_STRING;};
00234 void set(std::string * str) {for (unsigned int i=0; i<nelem; ++ i)
00235 {strcpy(val[i].str,str[i].c_str());} dataType=CAFE_STRING;};
00236
00237 std::string concatToString(){
00238 std::string psWF = "";
00239 if (dataTypeNative==CAFE_CHAR) {
00240 for (unsigned int i=0; i<nelem; ++i) {
00241 if (val[i].ch != '\0') {
00242 psWF.append(1, (dbr_char_t) val[i].ch);
00243 }
00244 }
00245 }
00246 return psWF;
00247 }
00248
00249 double getDouble(unsigned int idx) {return (double) val[idx].d;}
00250 float getFloat (unsigned int idx) {return (float) val[idx].f;}
00251 short getShort (unsigned int idx) {return (short) val[idx].s;}
00252 int getInt (unsigned int idx) {return (int) val[idx].l;}
00253 int getLong (unsigned int idx) {return (int) val[idx].l;}
00254 unsigned short getEnum (unsigned int idx) {return (unsigned short) val[idx].us;}
00255 unsigned short getUShort(unsigned int idx) {return (unsigned short) val[idx].us;}
00256 unsigned char getChar (unsigned int idx) {return (unsigned char ) val[idx].ch;}
00257
00258
00259
00260 dbr_string_t * getString(unsigned int idx) {
00261 #define __METHOD__ "PVHolder::getString "
00262 if (dataType!=CAFE_STRING) {
00263 cout << "******* WARNING *******" << endl;
00264 cout << __METHOD__ << __LINE__ << endl;
00265 cout << "DataType is " << (cafeDataTypeCode.message((CAFE_DATATYPE)dataType)).c_str() <<
00266 " hence getString method is invalid! " << endl;
00267 cout << "Use getAsString method if you wish to retrieve the data as a string! " << endl;
00268 cout << "**********************" << endl;
00269
00270 return (dbr_string_t *) "";
00271 }
00272 return (dbr_string_t *) val[idx].str;
00273 #undef __METHOD__
00274 }
00275
00276 boost::shared_ptr<vector<double> > getAsVDouble(){
00277 #define __METHOD__ "PVHolder::getVDouble "
00278
00279 ValVD_ptr.reset(new vector<double>());
00280
00281 switch (dataType)
00282 {
00283 case CAFE_DOUBLE:
00284 for (unsigned i=0; i<nelem; ++i) {ValVD_ptr->push_back(val[i].d);}
00285 break;
00286 case CAFE_FLOAT:
00287 for (unsigned i=0; i<nelem; ++i) {ValVD_ptr->push_back(val[i].f);}
00288 break;
00289 case CAFE_LONG:
00290 for (unsigned i=0; i<nelem; ++i) {ValVD_ptr->push_back(val[i].l);}
00291 break;
00292 case CAFE_SHORT:
00293 for (unsigned i=0; i<nelem; ++i) {ValVD_ptr->push_back(val[i].s);}
00294 break;
00295 case CAFE_ENUM:
00296 for (unsigned i=0; i<nelem; ++i) {ValVD_ptr->push_back(val[i].us);}
00297 break;
00298 case CAFE_CHAR:
00299 for (unsigned i=0; i<nelem; ++i) {ValVD_ptr->push_back(val[i].ch);}
00300 break;
00301 case CAFE_STRING:
00302 default:
00303 for (unsigned i=0; i<nelem; ++i) {ValVD_ptr->push_back( getAsDouble(i));}
00304 break;
00305 }
00306
00307 return ValVD_ptr;
00308 #undef __METHOD__
00309 }
00310
00311 boost::shared_ptr<vector<float> > getAsVFloat(){
00312 #define __METHOD__ "PVHolder::getVFloat "
00313
00314 ValVF_ptr.reset(new vector<float>());
00315
00316 switch (dataType)
00317 {
00318 case CAFE_DOUBLE:
00319 for (unsigned i=0; i<nelem; ++i) {ValVF_ptr->push_back((float) val[i].d);}
00320 break;
00321 case CAFE_FLOAT:
00322 for (unsigned i=0; i<nelem; ++i) {ValVF_ptr->push_back(val[i].f);}
00323 break;
00324 case CAFE_LONG:
00325 for (unsigned i=0; i<nelem; ++i) {ValVF_ptr->push_back(val[i].l);}
00326 break;
00327 case CAFE_SHORT:
00328 for (unsigned i=0; i<nelem; ++i) {ValVF_ptr->push_back(val[i].s);}
00329 break;
00330 case CAFE_ENUM:
00331 for (unsigned i=0; i<nelem; ++i) {ValVF_ptr->push_back(val[i].us);}
00332 break;
00333 case CAFE_CHAR:
00334 for (unsigned i=0; i<nelem; ++i) {ValVF_ptr->push_back(val[i].ch);}
00335 break;
00336 case CAFE_STRING:
00337 default:
00338 for (unsigned i=0; i<nelem; ++i) {ValVD_ptr->push_back( getAsFloat(i));}
00339 break;
00340 }
00341
00342
00343
00344
00345
00346
00347
00348 return ValVF_ptr;
00349 #undef __METHOD__
00350 }
00351
00352
00353 boost::shared_ptr<vector<int> > getAsVInt(){
00354 #define __METHOD__ "PVHolder::getVInt "
00355
00356 ValVI_ptr.reset(new vector<int>());
00357
00358 switch (dataType)
00359 {
00360 case CAFE_DOUBLE:
00361 for (unsigned i=0; i<nelem; ++i) {ValVI_ptr->push_back((int) val[i].d);}
00362 break;
00363 case CAFE_FLOAT:
00364 for (unsigned i=0; i<nelem; ++i) {ValVI_ptr->push_back((int) val[i].f);}
00365 break;
00366 case CAFE_LONG:
00367 for (unsigned i=0; i<nelem; ++i) {ValVI_ptr->push_back(val[i].l);}
00368 break;
00369 case CAFE_SHORT:
00370 for (unsigned i=0; i<nelem; ++i) {ValVI_ptr->push_back(val[i].s);}
00371 break;
00372 case CAFE_ENUM:
00373 for (unsigned i=0; i<nelem; ++i) {ValVI_ptr->push_back(val[i].us);}
00374 break;
00375 case CAFE_CHAR:
00376 for (unsigned i=0; i<nelem; ++i) {ValVI_ptr->push_back(val[i].ch);}
00377 break;
00378 case CAFE_STRING:
00379 default:
00380 for (unsigned i=0; i<nelem; ++i) {ValVI_ptr->push_back( getAsInt(i));}
00381 break;
00382 }
00383
00384 return ValVI_ptr;
00385 #undef __METHOD__
00386 }
00387
00388 boost::shared_ptr<vector<string> > getAsVString(){
00389 #define __METHOD__ "PVHolder::getVString "
00390
00391 ValVStr_ptr.reset(new vector<string>());
00392 for (unsigned i=0; i<nelem; ++i) {ValVStr_ptr->push_back( getAsString(i));}
00393
00394 return ValVStr_ptr;
00395 #undef __METHOD__
00396 }
00397
00398 ValDPtr getDouble(){
00399 #define __METHOD__ "PVHolder::getDouble "
00400 if (dataType!=CAFE_DOUBLE) {
00401 cout << "******* WARNING *******" << endl;
00402 cout << __METHOD__ << __LINE__ << endl;
00403 cout << "DataType is " << (cafeDataTypeCode.message((CAFE_DATATYPE)dataType)).c_str() <<
00404 " hence getDouble method is invalid! " << endl;
00405 cout << "Use getAsDouble method if you wish to retrieve the data as a double! " << endl;
00406 cout << "**********************" << endl;
00407 }
00408
00409 ValD_ptr.reset(new double[nelem]);
00410
00411 for (unsigned i=0; i<nelem; ++i) {
00412 ValD_ptr[i] = val[i].d;
00413 }
00414
00415 return ValD_ptr;
00416 #undef __METHOD__
00417 }
00418
00419 ValFPtr getFloat() {
00420 #define __METHOD__ "PVHolder::getFloat "
00421 if (dataType!=CAFE_FLOAT) {
00422 cout << "******* WARNING *******" << endl;
00423 cout << __METHOD__ << __LINE__ << endl;
00424 cout << "DataType is " << (cafeDataTypeCode.message((CAFE_DATATYPE)dataType)).c_str() <<
00425 " hence getFloat method is invalid! " << endl;
00426 cout << "Use getAsFloat method if you wish to retrieve the data as a float! " << endl;
00427 cout << "**********************" << endl;
00428 }
00429 ValF_ptr.reset(new float[nelem]);
00430 for (unsigned i=0; i<nelem; ++i) {
00431 ValF_ptr[i] = val[i].f;
00432 }
00433 return ValF_ptr;
00434
00435 #undef __METHOD__
00436 }
00437
00438 ValSPtr getShort() {
00439 #define __METHOD__ "PVHolder::getShort "
00440 if (dataType==CAFE_SHORT) {
00441 cout << "******* WARNING *******" << endl;
00442 cout << __METHOD__ << __LINE__ << endl;
00443 cout << "DataType is " << (cafeDataTypeCode.message((CAFE_DATATYPE)dataType)).c_str() <<
00444 " hence getShort method is invalid! " << endl;
00445 cout << "Use getAsShort method if you wish to retrieve the data as a short! " << endl;
00446 cout << "**********************" << endl;
00447 }
00448 ValS_ptr.reset(new short[nelem]);
00449 for (unsigned i=0; i<nelem; ++i) {
00450 ValS_ptr[i] = val[i].s;
00451 }
00452 return ValS_ptr;
00453
00454 #undef __METHOD__
00455 }
00456
00457 ValIPtr getInt(){
00458 #define __METHOD__ "PVHolder::getInt (meaning dbr_long_t) "
00459 if (dataType!=CAFE_LONG) {
00460 cout << "******* WARNING *******" << endl;
00461 cout << __METHOD__ << __LINE__ << endl;
00462 cout << "DataType is " << (cafeDataTypeCode.message((CAFE_DATATYPE)dataType)).c_str() <<
00463 " hence getInt method is invalid! " << endl;
00464 cout << "Use getAsInt method if you wish to retrieve the data as a int! " << endl;
00465 cout << "**********************" << endl;
00466 }
00467 ValI_ptr.reset(new int[nelem]);
00468 for (unsigned i=0; i<nelem; ++i) {
00469 ValI_ptr[i] = val[i].l;
00470 }
00471 return ValI_ptr;
00472 #undef __METHOD__
00473 }
00474
00475 ValIPtr getLong(){
00476 #define __METHOD__ "PVHolder::getLong (meaning dbr_long_t) "
00477 if (dataType!=CAFE_LONG) {
00478 cout << "******* WARNING *******" << endl;
00479 cout << __METHOD__ << __LINE__ << endl;
00480 cout << "DataType is " << (cafeDataTypeCode.message((CAFE_DATATYPE)dataType)).c_str() <<
00481 " hence getLong method is invalid! " << endl;
00482 cout << "Use getAsLong method if you wish to retrieve the data as a dbr_long_t! " << endl;
00483 cout << "**********************" << endl;
00484 }
00485 ValI_ptr.reset(new int[nelem]);
00486 for (unsigned i=0; i<nelem; ++i) {
00487 ValI_ptr[i] = val[i].l;
00488 }
00489 return ValI_ptr;
00490 #undef __METHOD__
00491 }
00492
00493 ValUSPtr getEnum(){
00494 #define __METHOD__ "PVHolder::getEnum "
00495 if (dataType!=CAFE_ENUM) {
00496 cout << "******* WARNING *******" << endl;
00497 cout << __METHOD__ << __LINE__ << endl;
00498 cout << "DataType is " << (cafeDataTypeCode.message((CAFE_DATATYPE)dataType)).c_str() <<
00499 " hence getEnum method is invalid! " << endl;
00500 cout << "Use getAsEnum method if you wish to retrieve the data as an enum (unsigned short)! " << endl;
00501 cout << "**********************" << endl;
00502 }
00503 ValUS_ptr.reset(new unsigned short[nelem]);
00504 for (unsigned i=0; i<nelem; ++i) {
00505 ValUS_ptr[i] = val[i].us;
00506 }
00507 return ValUS_ptr;
00508 #undef __METHOD__
00509 }
00510
00511 ValUSPtr getUShort(){
00512 #define __METHOD__ "PVHolder::getUShort "
00513 if (dataType!=CAFE_USHORT) {
00514 cout << "******* WARNING *******" << endl;
00515 cout << __METHOD__ << __LINE__ << endl;
00516 cout << "DataType is " << (cafeDataTypeCode.message((CAFE_DATATYPE)dataType)).c_str() <<
00517 " hence getUShort method is invalid! " << endl;
00518 cout << "Use getAsUSHort method if you wish to retrieve the data as an unsigned short! " << endl;
00519 cout << "**********************" << endl;
00520 }
00521 ValUS_ptr.reset(new unsigned short[nelem]);
00522 for (unsigned i=0; i<nelem; ++i) {
00523 ValUS_ptr[i] = val[i].us;
00524 }
00525 return ValUS_ptr;
00526 #undef __METHOD__
00527 }
00528
00529 ValChPtr getChar(){
00530 #define __METHOD__ "PVHolder::getChar "
00531 if (dataType!=CAFE_CHAR) {
00532 cout << "******* WARNING *******" << endl;
00533 cout << __METHOD__ << __LINE__ << endl;
00534 cout << "DataType is " << (cafeDataTypeCode.message((CAFE_DATATYPE)dataType)).c_str() <<
00535 " hence getChar method is invalid! " << endl;
00536 cout << "Use getAsChar method if you wish to retrieve the data as a char! " << endl;
00537 cout << "**********************" << endl;
00538 }
00539 ValCh_ptr.reset(new unsigned char[nelem]);
00540 for (unsigned i=0; i<nelem; ++i) {
00541 ValCh_ptr[i] = val[i].ch;
00542 }
00543 return ValCh_ptr;
00544 #undef __METHOD__
00545 }
00546
00547 ValStrPtr getString() {
00548 #define __METHOD__ "PVHolder::getString "
00549 if (dataType!=CAFE_STRING) {
00550 cout << "******* WARNING *******" << endl;
00551 cout << __METHOD__ << __LINE__ << endl;
00552 cout << "DataType is " << (cafeDataTypeCode.message((CAFE_DATATYPE)dataType)).c_str() <<
00553 " hence getString method is invalid! " << endl;
00554 cout << "Use getAsString method if you wish to retrieve the data as a string! " << endl;
00555 cout << "**********************" << endl;
00556
00557 }
00558 ValStr_ptr.reset(new dbr_string_t[nelem]);
00559 for (unsigned i=0; i<nelem; ++i) {
00560 strcpy(ValStr_ptr[i] , val[i].str);
00561 }
00562 return ValStr_ptr;
00563 #undef __METHOD__
00564 }
00565
00566 double getAsDouble () {
00567 return (double) renderDouble.get(0, dataType, val.get())[0];
00568 }
00569
00570 double getAsDouble(unsigned int idx) throw(std::out_of_range){
00571 if(isIndexOutOfRange(idx)) {
00572 std::ostringstream oss;
00573 oss << "Exception! Index " << idx
00574 << " to PVHolder method is out of range. Valid range is from 0 to " << size-1;
00575 throw std::out_of_range(oss.str());
00576 }
00577 return (double) renderDouble.get(idx, dataType, val.get())[0];
00578 }
00579
00580 float getAsFloat () {
00581 return (float) renderFloat.get(0, dataType, val.get())[0];
00582 }
00583
00584 float getAsFloat(unsigned int idx) throw(std::out_of_range){
00585 if(isIndexOutOfRange(idx)) {
00586 std::ostringstream oss;
00587 oss << "Exception! Index " << idx
00588 << " to PVHolder method is out of range. Valid range is from 0 to " << size-1;
00589 throw std::out_of_range(oss.str());
00590 }
00591 return (float) renderFloat.get(idx, dataType, val.get())[0];
00592 }
00593
00594 short getAsShort () {
00595 return (short) renderShort.get(0, dataType, val.get())[0];
00596 }
00597
00598 short getAsShort(unsigned int idx) throw(std::out_of_range){
00599 if(isIndexOutOfRange(idx)) {
00600 std::ostringstream oss;
00601 oss << "Exception! Index " << idx
00602 << " to PVHolder method is out of range. Valid range is from 0 to " << size-1;
00603 throw std::out_of_range(oss.str());
00604 }
00605 return (short) renderShort.get(idx, dataType, val.get())[0];
00606 }
00607
00608 int getAsLong () {
00609 return (int) renderLong.get(0, dataType, val.get())[0];
00610 }
00611
00612 int getAsLong(unsigned int idx) throw(std::out_of_range){
00613 if(isIndexOutOfRange(idx)) {
00614 std::ostringstream oss;
00615 oss << "Exception! Index " << idx
00616 << " to PVHolder method is out of range. Valid range is from 0 to " << size-1;
00617 throw std::out_of_range(oss.str());
00618 }
00619 return (int) renderLong.get(idx, dataType, val.get())[0];
00620 }
00621
00622 unsigned short getAsEnum () {
00623 return (unsigned short) renderEnum.get(0, dataType, val.get())[0];
00624 }
00625
00626 unsigned short getAsEnum(unsigned int idx) throw(std::out_of_range){
00627 if(isIndexOutOfRange(idx)) {
00628 std::ostringstream oss;
00629 oss << "Exception! Index " << idx
00630 << " to PVHolder method is out of range. Valid range is from 0 to " << size-1;
00631 throw std::out_of_range(oss.str());
00632 }
00633 return (unsigned short) renderEnum.get(idx, dataType, val.get())[0];
00634 }
00635
00636 unsigned short getAsUShort () {
00637 return (unsigned short) renderEnum.get(0, dataType, val.get())[0];
00638 }
00639
00640 unsigned short getAsUShort(unsigned int idx) throw(std::out_of_range){
00641 if(isIndexOutOfRange(idx)) {
00642 std::ostringstream oss;
00643 oss << "Exception! Index " << idx
00644 << " to PVHolder method is out of range. Valid range is from 0 to " << size-1;
00645 throw std::out_of_range(oss.str());
00646 }
00647 return (unsigned short) renderEnum.get(idx, dataType, val.get())[0];
00648 }
00649
00650 unsigned char getAsChar () {
00651 return (char) renderChar.get(0, dataType, val.get())[0];
00652 }
00653
00654 unsigned char getAsChar(unsigned int idx) throw(std::out_of_range){
00655 if(isIndexOutOfRange(idx)) {
00656 std::ostringstream oss;
00657 oss << "Exception! Index " << idx
00658 << " to PVHolder method is out of range. Valid range is from 0 to " << size-1;
00659 throw std::out_of_range(oss.str());
00660 }
00661 return (char) renderChar.get(idx, dataType, val.get())[0];
00662 }
00663
00664 unsigned char getAsUChar () {
00665 return (unsigned char) renderUChar.get(0, dataType, val.get())[0];
00666 }
00667
00668 unsigned char getAsUChar(unsigned int idx) throw(std::out_of_range){
00669 if(isIndexOutOfRange(idx)) {
00670 std::ostringstream oss;
00671 oss << "Exception! Index " << idx
00672 << " to PVHolder method is out of range. Valid range is from 0 to " << size-1;
00673 throw std::out_of_range(oss.str());
00674 }
00675 return (unsigned char) renderUChar.get(idx, dataType, val.get())[0];
00676 }
00677
00678 unsigned int getAsULong () {
00679 return (unsigned int) renderULong.get(0, dataType, val.get())[0];
00680 }
00681
00682 unsigned int getAsULong(unsigned int idx) throw(std::out_of_range){
00683 if(isIndexOutOfRange(idx)) {
00684 std::ostringstream oss;
00685 oss << "Exception! Index " << idx
00686 << " to PVHolder method is out of range. Valid range is from 0 to " << size-1;
00687 throw std::out_of_range(oss.str());
00688 }
00689 return (unsigned int) renderULong.get(idx, dataType, val.get())[0];
00690 }
00691
00692 long long getAsLongLong () {
00693 return (long long) renderLongLong.get(0, dataType, val.get())[0];
00694 }
00695
00696 long long getAsLongLong(unsigned int idx) throw(std::out_of_range){
00697 if(isIndexOutOfRange(idx)) {
00698 std::ostringstream oss;
00699 oss << "Exception! Index " << idx
00700 << " to PVHolder method is out of range. Valid range is from 0 to " << size-1;
00701 throw std::out_of_range(oss.str());
00702 }
00703 return (long long) renderLongLong.get(idx, dataType, val.get())[0];
00704 }
00705
00706 unsigned long long getAsULongLong () {
00707 return (unsigned long long) renderULongLong.get(0, dataType, val.get())[0];
00708 }
00709
00710 unsigned long long getAsULongLong(unsigned int idx) throw(std::out_of_range){
00711 if(isIndexOutOfRange(idx)) {
00712 std::ostringstream oss;
00713 oss << "Exception! Index " << idx
00714 << " to PVHolder method is out of range. Valid range is from 0 to " << size-1;
00715 throw std::out_of_range(oss.str());
00716 }
00717 return (unsigned long long) renderULongLong.get(idx, dataType, val.get())[0];
00718 }
00719
00720 int getAsInt () {
00721 return (int) renderInt.get(0, dataType, val.get())[0];
00722 }
00723
00724 int getAsInt(unsigned int idx) throw(std::out_of_range){
00725 if(isIndexOutOfRange(idx)) {
00726 std::ostringstream oss;
00727 oss << "Exception! Index " << idx
00728 << " to PVHolder method is out of range. Valid range is from 0 to " << size-1;
00729 throw std::out_of_range(oss.str());
00730 }
00731 return (int) renderInt.get(idx, dataType, val.get())[0];
00732 }
00733
00734 unsigned int getAsUInt () {
00735 return (unsigned int) renderInt.get(0, dataType, val.get())[0];
00736 }
00737
00738 unsigned int getAsUInt(unsigned int idx) throw(std::out_of_range){
00739 if(isIndexOutOfRange(idx)) {
00740 std::ostringstream oss;
00741 oss << "Exception! Index " << idx
00742 << " to PVHolder method is out of range. Valid range is from 0 to " << size-1;
00743 throw std::out_of_range(oss.str());
00744 }
00745 return (unsigned int) renderInt.get(idx, dataType, val.get())[0];
00746 }
00747
00748
00749 string getEnumIntegerValueAsString() {
00750 #define __METHOD__ "PVHolder::getEnumIntegerValueAsString"
00751 if (dataType!=CAFE_ENUM) {
00752 cout << "******* WARNING *******" << endl;
00753 cout << __METHOD__ << __LINE__ << endl;
00754 cout << "DataType is " << (cafeDataTypeCode.message((CAFE_DATATYPE)dataType)).c_str() <<
00755 " hence getEnumIntegerValueAsString method is invalid! " << endl;
00756 cout << "Use getAsString method if you want the string equilavent of the ENUM value!" << endl;
00757 cout << "**********************" << endl;
00758 }
00759 return (string) renderString.getString(0, dataType, val.get())[0];
00760 #undef __METHOD__
00761 }
00762
00763 string getAsString() {
00764 if(dataTypeNative==DBR_ENUM && dataType==DBR_ENUM) {
00765
00766 return (string) renderString.getStringFromEnum(0, noStr, val.get(), strs)[0];
00767 }
00768 else {
00769 return (string) renderString.getString(0, dataType, val.get())[0];
00770 }
00771 }
00772
00773 string getAsString(unsigned int idx) throw(std::out_of_range){
00774 if(isIndexOutOfRange(idx)) {
00775 std::ostringstream oss;
00776 oss << "Exception! Index " << idx
00777 << " to PVHolder method is out of range. Valid range is from 0 to " << size-1;
00778 throw std::out_of_range(oss.str());
00779 }
00780 if(dataTypeNative==DBR_ENUM && dataType==CAFE_ENUM) {
00781 return (string) renderString.getStringFromEnum(idx, noStr, val.get(), strs)[0];
00782 }
00783 else {
00784 return (string) renderString.getString(idx, dataType, val.get())[0];
00785 }
00786 }
00787
00788
00789 char * getAsDbr_string_t() {
00790 if(dataTypeNative==DBR_ENUM && dataType==CAFE_ENUM) {
00791 return (char *) renderString.getStringFromEnum(0, noStr, val.get(), strs)[0];
00792
00793 }
00794 else {
00795 return (char *) renderString.getString(0, dataType, val.get())[0];
00796 }
00797 }
00798
00799
00800 char * getAsDbr_string_t(unsigned int idx) throw(std::out_of_range){
00801 if(isIndexOutOfRange(idx)) {
00802 std::ostringstream oss;
00803 oss << "Exception! Index " << idx
00804 << " to PVHolder method is out of range. Valid range is from 0 to " << size-1;
00805 throw std::out_of_range(oss.str());
00806 }
00807 if(dataTypeNative==DBR_ENUM && dataType==CAFE_ENUM) {
00808 return (char *) renderString.getStringFromEnum(idx, noStr, val.get(), strs)[0];
00809 }
00810 else {
00811 return (char *) renderString.getString(idx, dataType, val.get())[0];
00812 }
00813 }
00814
00815
00816
00817
00818
00819
00820
00821
00822
00823
00824
00825
00826
00827
00828
00829
00830
00831
00832
00833 double getAsDouble(CAFE_DATATYPE_UNION cdu) {
00834 return (double) renderDouble.get(0, dataType, &cdu)[0];
00835 }
00836
00837 float getAsFloat(CAFE_DATATYPE_UNION cdu) {
00838 return (float) renderFloat.get(0, dataType, &cdu)[0];
00839 }
00840
00841 short getAsShort(CAFE_DATATYPE_UNION cdu) {
00842 return (short) renderShort.get(0, dataType, &cdu)[0];
00843 }
00844
00845 int getAsLong(CAFE_DATATYPE_UNION cdu) {
00846 return (int) renderLong.get(0, dataType, &cdu)[0];
00847 }
00848
00849 unsigned short getAsEnum(CAFE_DATATYPE_UNION cdu) {
00850 return (unsigned short) renderEnum.get(0, dataType, &cdu)[0];
00851 }
00852
00853 unsigned short getAsUShort(CAFE_DATATYPE_UNION cdu) {
00854 return (unsigned short) renderEnum.get(0, dataType, &cdu)[0];
00855 }
00856
00857 char getAsChar(CAFE_DATATYPE_UNION cdu) {
00858 char * ans = renderChar.get(0, dataType, &cdu);
00859 return (char ) ans[0];
00860 }
00861 unsigned char getAsUChar(CAFE_DATATYPE_UNION cdu) {
00862 unsigned char * ans = renderUChar.get(0, dataType, &cdu);
00863 return (unsigned char ) ans[0];
00864 }
00865
00866 string getAsString(CAFE_DATATYPE_UNION cdu) {
00867 return (string) renderString.getString(dataType, cdu)[0];
00868 }
00869
00870 char * getAsDbr_string_t(CAFE_DATATYPE_UNION cdu) {
00871 return (char *) renderString.getString(0, dataType, &cdu)[0];
00872 }
00873 };
00874
00875
00876 #endif //PVHOLDER_H