00001
00002
00003
00004
00005
00006
00007
00008 #ifndef TRANSPOSE_H
00009 #define TRANSPOSE_H
00010
00011 #include <cadef.h>
00012 #include <global.h>
00013 #include <statusCodes.h>
00014 #include <handleHelper.h>
00015
00016 using namespace std;
00017
00030 template <class CTYPE> class Transpose {
00031
00032 public:
00033 Transpose (){};
00034 ~Transpose (){};
00035
00036 HandleHelper handleHelper;
00037
00038 int put(const unsigned int _handle, const CTYPE * val, const chtype cdt);
00039 int put(const unsigned int _handle, CAFE_DATATYPE_UNION_SEQ val, CAFE_DATATYPE cdt);
00040 int putString (const unsigned int _handle, dbr_string_t * val);
00041
00042 int get(
00043 const unsigned int _handle, CTYPE * val,
00044 dbr_short_t & alarmStatus, dbr_short_t &alarmSeverity, epicsTimeStamp &ts, bool isCacheRequest);
00045
00046
00047 int get(
00048
00049
00050 const unsigned int _handle, CTYPE * val,
00051 dbr_short_t & alarmStatus, dbr_short_t &alarmSeverity, bool isCacheRequest) {
00052
00053 epicsTimeStamp ts;
00054 alarmStatus =0;
00055 alarmSeverity =0;
00056
00057 return get (
00058
00059
00060 _handle, val, alarmStatus, alarmSeverity, ts, isCacheRequest);
00061 };
00062
00063
00064 int get(
00065
00066
00067 const unsigned int _handle, CTYPE * val, bool isCacheRequest) {
00068 epicsTimeStamp ts;
00069 dbr_short_t alarmStatus;
00070 dbr_short_t alarmSeverity;
00071
00072 ts.secPastEpoch=0;
00073 ts.nsec =0;
00074 alarmStatus =0;
00075 alarmSeverity =0;
00076
00077 return get(
00078
00079
00080 _handle, val, alarmStatus, alarmSeverity, ts, isCacheRequest);
00081 };
00082
00083
00084 int getCtrl (
00085
00086
00087
00088 const unsigned int _handle, CTYPE * val,
00089 dbr_short_t &alarmStatus, dbr_short_t &alarmSeverity, dbr_short_t &precision,
00090 CTYPE &RISC_pad,
00091 CTYPE &upperDispLimit, CTYPE &lowerDispLimit,
00092 CTYPE &upperAlarmLimit, CTYPE &upperWarningLimit,
00093 CTYPE &lowerWarningLimit, CTYPE &lowerAlarmLimit,
00094 CTYPE &upperCtrlLimit, CTYPE &lowerCtrlLimit,
00095 char units[MAX_UNITS_SIZE], short &noStr, char strs [MAX_ENUM_STATES][MAX_ENUM_STRING_SIZE], bool isCacheRequest);
00096
00097
00098
00099 private:
00100 CTYPE * val;
00101 int status;
00102 CAFEStatus cafeStatus;
00103 CAFEDataTypeCode cafeDataTypeCode;
00104 union db_access_val * PVDataL;
00105 unsigned int nelem;
00106 unsigned int offset;
00107 chtype dbrTypeRequest_DataBuffer;
00108 chtype dbrTypeRequest_CtrlBuffer;
00109 chtype _dataTypeClient;
00110 char stig [MAX_ENUM_STATES][MAX_ENUM_STRING_SIZE];
00111
00112 };
00113
00114
00116
00117
00121 template <> class Transpose <dbr_string_t> {
00122
00123 public:
00124 Transpose (){};
00125 ~Transpose (){};
00126 int putString (const unsigned int _handle, dbr_string_t * val);
00127 int putString (const unsigned int _handle, CAFE_DATATYPE_UNION_SEQ val);
00128
00129 int get(
00130
00131
00132 const unsigned int _handle, dbr_string_t * val,
00133 dbr_short_t & alarmStatus, dbr_short_t &alarmSeverity, epicsTimeStamp &ts, bool isCacheRequest );
00134
00135
00136 int get(
00137
00138
00139 const unsigned int _handle, dbr_string_t * val,
00140 dbr_short_t & alarmStatus, dbr_short_t &alarmSeverity, bool isCacheRequest ) {
00141
00142 epicsTimeStamp ts;
00143 alarmStatus =0;
00144 alarmSeverity =0;
00145
00146 return get (
00147
00148
00149 _handle, val, alarmStatus, alarmSeverity, ts, isCacheRequest);
00150 };
00151
00152
00153 int get(
00154
00155
00156 const unsigned int _handle, dbr_string_t * val, bool isCacheRequest) {
00157 epicsTimeStamp ts;
00158 dbr_short_t alarmStatus;
00159 dbr_short_t alarmSeverity;
00160
00161 ts.secPastEpoch=0;
00162 ts.nsec =0;
00163 alarmStatus =0;
00164 alarmSeverity =0;
00165
00166 return get (
00167
00168
00169 _handle, val, alarmStatus, alarmSeverity, ts, isCacheRequest );
00170 };
00171
00172
00173 int getCtrl(
00174 const unsigned int _handle, dbr_string_t * val,
00175 dbr_short_t & alarmStatus, dbr_short_t &alarmSeverity, bool isCacheRequest );
00176
00177 private:
00178 int status;
00179 CAFEStatus cafeStatus;
00180 union db_access_val * PVDataL;
00181 unsigned int nelem;
00182 unsigned int offset;
00183 chtype dbrTypeRequest_DataBuffer;
00184 chtype dbrTypeRequest_CtrlBuffer;
00185 chtype _dataTypeClient;
00186 char stig [MAX_ENUM_STATES][MAX_ENUM_STRING_SIZE];
00187 };
00188
00189
00190
00191
00193
00194
00195
00199 template <> class Transpose <CAFE_DATATYPE_UNION> {
00200
00201 public:
00202 Transpose (){};
00203 ~Transpose (){};
00204
00205
00206
00207
00208
00209 int get(
00210 const unsigned int _handle, CAFE_DATATYPE_UNION_SEQ val,
00211 dbr_short_t & alarmStatus, dbr_short_t &alarmSeverity, epicsTimeStamp &ts, bool isCacheRequest);
00212
00213 int get(
00214 const unsigned int _handle, CAFE_DATATYPE_UNION_SEQ val,
00215 dbr_short_t & alarmStatus, dbr_short_t &alarmSeverity, bool isCacheRequest) {
00216
00217 epicsTimeStamp ts;
00218 alarmStatus =0;
00219 alarmSeverity =0;
00220
00221 return get (_handle, val, alarmStatus, alarmSeverity, ts, isCacheRequest);
00222 };
00223
00224
00225 int get(
00226 const unsigned int _handle, CAFE_DATATYPE_UNION_SEQ val, bool isCacheRequest) {
00227 epicsTimeStamp ts;
00228 dbr_short_t alarmStatus;
00229 dbr_short_t alarmSeverity;
00230
00231 ts.secPastEpoch=0;
00232 ts.nsec =0;
00233 alarmStatus =0;
00234 alarmSeverity =0;
00235
00236 return get (_handle, val, alarmStatus, alarmSeverity, ts, isCacheRequest);
00237 };
00238
00239 private:
00240 int status;
00241 CAFEStatus cafeStatus;
00242 union db_access_val * PVDataL;
00243 unsigned int nelem;
00244 unsigned int offset;
00245 chtype dbrTypeRequest_DataBuffer;
00246 chtype _dataTypeClient;
00247 char stig [MAX_ENUM_STATES][MAX_ENUM_STRING_SIZE];
00248 };
00249
00250
00258 template <class CTYPE> int Transpose<CTYPE>::put(const unsigned int _handle,
00259 const CTYPE * val, const chtype _dbrType)
00260 {
00261 #define __METHOD__ "Transpose<CTYPE>::put(_handle, CTYPE * val, const chtype cdt)"
00262
00263 status=ICAFE_NORMAL;
00264
00265 cafeConduit_set_by_handle & handle_index = cs.get<by_handle> ();
00266 cafeConduit_set_by_handle::iterator it_handle;
00267
00268
00269 it_handle = handle_index.find(_handle);
00270
00271 if (it_handle != handle_index.end()) {
00272
00273
00274 PVDataL = (*it_handle).getPutBuffer ();
00275 nelem = (*it_handle).getChannelRequestMetaPrimitive().getNelem();
00276
00277
00278 dbrTypeRequest_DataBuffer = (*it_handle).getChannelRequestMetaPrimitive().getDbrDataType();
00279
00280
00281
00282
00283
00284
00285
00286 if (dbrTypeRequest_DataBuffer==DBR_ENUM) {
00287
00288 dbr_ctrl_enum * dataEnum = (dbr_ctrl_enum *) (*it_handle).getCtrlBuffer();
00289 dbr_short_t noStrings = ((struct dbr_ctrl_enum *) dataEnum)->no_str;
00290
00291 if(noStrings >0) {
00292
00293 for (unsigned int i=0; i<nelem; ++i) {
00294
00295 if ( (dbr_enum_t) val[i] >= noStrings ) {
00296
00297 memcpy( stig, &(((struct dbr_ctrl_enum *) dataEnum)->strs), sizeof(stig )) ;
00298
00299
00300 cout << __FILE__ << "//" << __LINE__ << "//" <<__METHOD__ << endl;
00301 cafeStatus.report(ECAFE_INVALID_ENUM_INDEX);
00302 cout << val[i] << " is not a a valid enum index " << endl;
00303 cout << "VALID STRING [ENUM] OPTIONS ARE: " << endl;
00304 for (dbr_short_t ij=0; ij<noStrings; ++ij) {
00305 cout << "'" << stig[ij] << "' " << "[" << ij << "]" << "; ";
00306 }
00307 cout << endl;
00308 return ECAFE_INVALID_ENUM_INDEX;
00309 }
00310 }
00311 }
00312
00313 }
00314
00315 switch (dbrTypeRequest_DataBuffer)
00316 {
00317 case DBR_STRING:
00318 switch(_dbrType){
00319 case CAFE_SHORT:
00320 for (unsigned int i=0; i<nelem; ++i) {
00321 sprintf(*((dbr_string_t *) (PVDataL) + i ),
00322 "%d", *reinterpret_cast<const short*>(&val[i]));
00323 }
00324 break;
00325 case CAFE_FLOAT:
00326 for (unsigned int i=0; i<nelem; ++i) {
00327 sprintf(*((dbr_string_t *) (PVDataL) + i ) ,
00328 "%f", *reinterpret_cast<const float*>(&val[i]));
00329 }
00330 break;
00331 case CAFE_ENUM:
00332 for (unsigned int i=0; i<nelem; ++i) {
00333 sprintf(*((dbr_string_t *) (PVDataL) + i ) ,
00334 "%u", *reinterpret_cast<const unsigned short*>(&val[i]));
00335 }
00336 break;
00337 case CAFE_CHAR:
00338 for (unsigned int i=0; i<nelem; ++i) {
00339 sprintf(*((dbr_string_t *) (PVDataL) + i ) ,
00340 "%u", *reinterpret_cast<const char*>(&val[i]));
00341 }
00342 break;
00343 case CAFE_LONG:
00344 for (unsigned int i=0; i<nelem; ++i) {
00345 sprintf(*((dbr_string_t *) (PVDataL) + i ) ,
00346 "%d", *reinterpret_cast<const int*>(&val[i]));
00347 }
00348 break;
00349 case CAFE_DOUBLE:
00350 for (unsigned int i=0; i<nelem; ++i) {
00351 sprintf(*((dbr_string_t *) (PVDataL) + i ) ,
00352 "%.15f", *reinterpret_cast<const double*>(&val[i]));
00353 }
00354 break;
00355 case CAFE_STRING:
00356 memcpy( PVDataL, val, sizeof(dbr_string_t)*nelem);
00357
00358 break;
00359 default:
00360 cout << "ERROR: " << __FILE__ << "/" << __LINE__ << "/" << __METHOD__ << endl;
00361 cafeStatus.report(ECAFE_INVALID_SWITCH_CASE);
00362 cout << "SWITCH STATMENT NOT MEANT FOR CAFE DATATYPE=" << _dbrType <<endl;
00363 cout << cafeDataTypeCode.message(_dbrType) << endl;
00364 cout << "ABORTING DATA CONVERTION TO LOCAL putBuffer" << endl;
00365 cout << "LIKELY THAT THE DATA_TYPE WAS NOT MADE KNOWN IN THE INPUT PARAMETERS" << endl;
00366
00367 return ECAFE_INVALID_SWITCH_CASE;
00368 break;
00369 }
00370
00371 break;
00372
00373 case DBR_SHORT:
00374 switch(_dbrType) {
00375 case DBR_SHORT:
00376 memcpy( PVDataL, val, sizeof(dbr_short_t)*nelem);
00377
00378 break;
00379 case DBR_FLOAT:
00380 for (unsigned int i=0; i<nelem; ++i) {
00381 *((dbr_short_t *) (PVDataL) + i ) = (dbr_short_t) val[i] ;
00382 }
00383 break;
00384 case DBR_ENUM:
00385 for (unsigned int i=0; i<nelem; ++i) {
00386 *((dbr_short_t *) (PVDataL) + i ) = (dbr_short_t) val[i] ;
00387 }
00388 break;
00389 case DBR_CHAR:
00390 for (unsigned int i=0; i<nelem; ++i) {
00391 *((dbr_short_t *) (PVDataL) + i ) = (dbr_short_t) val[i] ;
00392 }
00393 break;
00394 case DBR_LONG:
00395 for (unsigned int i=0; i<nelem; ++i) {
00396 *((dbr_short_t *) (PVDataL) + i ) = (dbr_short_t) val[i] ;
00397 }
00398 break;
00399 case DBR_DOUBLE:
00400 for (unsigned int i=0; i<nelem; ++i) {
00401 *((dbr_short_t *) (PVDataL) + i ) = (dbr_short_t) val[i] ;
00402 }
00403 break;
00404 case DBR_STRING:
00405 status=putString(_handle, (dbr_string_t *) val);
00406
00407 break;
00408 default:
00409 cout << "ERROR: " << __FILE__ << "/" << __LINE__ << "/" << __METHOD__ << endl;
00410 cafeStatus.report(ECAFE_INVALID_SWITCH_CASE);
00411 cout << "SWITCH STATMENT NOT MEANT FOR CAFE DATATYPE=" << _dbrType <<endl;
00412 cout << cafeDataTypeCode.message(_dbrType) << endl;
00413 cout << "ABORTING DATA CONVERTION TO LOCAL putBuffer" << endl;
00414 cout << "LIKELY THAT THE DATA_TYPE WAS NOT MADE KNOWN IN THE INPUT PARAMETERS" << endl;
00415
00416 return ECAFE_INVALID_SWITCH_CASE;
00417 break;
00418 }
00419 break;
00420 case DBR_FLOAT:
00421 switch(_dbrType) {
00422 case DBR_SHORT:
00423 for (unsigned int i=0; i<nelem; ++i) {
00424 *((dbr_float_t *) (PVDataL) + i ) = (dbr_float_t) val[i] ;
00425 }
00426 break;
00427 case DBR_FLOAT:
00428 memcpy( PVDataL, val, sizeof(dbr_float_t)*nelem);
00429
00430 break;
00431 case DBR_ENUM:
00432 for (unsigned int i=0; i<nelem; ++i) {
00433 *((dbr_float_t *) (PVDataL) + i ) = (dbr_float_t) val[i] ;
00434 }
00435 break;
00436 case DBR_CHAR:
00437 for (unsigned int i=0; i<nelem; ++i) {
00438 *((dbr_float_t *) (PVDataL) + i ) = (dbr_float_t) val[i] ;
00439 }
00440 break;
00441 case DBR_LONG:
00442 for (unsigned int i=0; i<nelem; ++i) {
00443 *((dbr_float_t *) (PVDataL) + i ) = (dbr_float_t) val[i] ;
00444 }
00445 break;
00446 case DBR_DOUBLE:
00447 for (unsigned int i=0; i<nelem; ++i) {
00448 *((dbr_float_t *) (PVDataL) + i ) = (dbr_float_t) val[i] ;
00449 }
00450 break;
00451 case DBR_STRING:
00452 status=putString(_handle, (dbr_string_t *) val);
00453
00454 break;
00455 default:
00456 cout << "ERROR: " << __FILE__ << "/" << __LINE__ << "/" << __METHOD__ << endl;
00457 cafeStatus.report(ECAFE_INVALID_SWITCH_CASE);
00458 cout << "SWITCH STATMENT NOT MEANT FOR CAFE DATATYPE=" << _dbrType <<endl;
00459 cout << cafeDataTypeCode.message(_dbrType) << endl;
00460 cout << "ABORTING DATA CONVERTION TO LOCAL putBuffer" << endl;
00461 cout << "LIKELY THAT THE DATA_TYPE WAS NOT MADE KNOWN IN THE INPUT PARAMETERS" << endl;
00462
00463 return ECAFE_INVALID_SWITCH_CASE;
00464 break;
00465 }
00466 break;
00467 case DBR_ENUM:
00468
00469
00470 switch(_dbrType) {
00471 case DBR_SHORT:
00472 for (unsigned int i=0; i<nelem; ++i) {
00473 *((dbr_enum_t *) (PVDataL) + i ) = (dbr_enum_t) val[i] ;
00474 }
00475 break;
00476 case DBR_FLOAT:
00477 for (unsigned int i=0; i<nelem; ++i) {
00478 *((dbr_enum_t *) (PVDataL) + i ) = (dbr_enum_t) val[i] ;
00479 }
00480 break;
00481 case DBR_ENUM:
00482 memcpy( PVDataL, val, sizeof(dbr_enum_t)*nelem);
00483
00484 break;
00485 case DBR_CHAR:
00486 for (unsigned int i=0; i<nelem; ++i) {
00487 *((dbr_enum_t *) (PVDataL) + i ) = (dbr_enum_t) val[i] ;
00488 }
00489 break;
00490 case DBR_LONG:
00491 for (unsigned int i=0; i<nelem; ++i) {
00492 *((dbr_enum_t *) (PVDataL) + i ) = (dbr_enum_t) val[i] ;
00493 }
00494 break;
00495 case DBR_DOUBLE:
00496 for (unsigned int i=0; i<nelem; ++i) {
00497 *((dbr_enum_t *) (PVDataL) + i ) = (dbr_enum_t) val[i] ;
00498 }
00499 break;
00500 case DBR_STRING:
00501 status=putString(_handle, (dbr_string_t *) val);
00502
00503 break;
00504 default:
00505 cout << "ERROR: " << __FILE__ << "/" << __LINE__ << "/" << __METHOD__ << endl;
00506 cafeStatus.report(ECAFE_INVALID_SWITCH_CASE);
00507 cout << "SWITCH STATMENT NOT MEANT FOR CAFE DATATYPE=" << _dbrType <<endl;
00508 cout << cafeDataTypeCode.message(_dbrType) << endl;
00509 cout << "ABORTING DATA CONVERTION TO LOCAL putBuffer" << endl;
00510 cout << "LIKELY THAT THE DATA_TYPE WAS NOT MADE KNOWN IN THE INPUT PARAMETERS" << endl;
00511
00512 return ECAFE_INVALID_SWITCH_CASE;
00513 break;
00514 }
00515
00516 break;
00517
00518 case DBR_CHAR:
00519 switch(_dbrType) {
00520 case DBR_SHORT:
00521 for (unsigned int i=0; i<nelem; ++i) {
00522 *((dbr_char_t *) (PVDataL) + i ) = (dbr_char_t) val[i] ;
00523 }
00524 break;
00525 case DBR_FLOAT:
00526 for (unsigned int i=0; i<nelem; ++i) {
00527 *((dbr_char_t *) (PVDataL) + i ) = (dbr_char_t) val[i] ;
00528 }
00529 break;
00530 case DBR_ENUM:
00531 for (unsigned int i=0; i<nelem; ++i) {
00532 *((dbr_char_t *) (PVDataL) + i ) = (dbr_char_t) val[i] ;
00533 }
00534 break;
00535 case DBR_CHAR:
00536 memcpy( PVDataL, val, sizeof(dbr_char_t)*nelem);
00537
00538 break;
00539 case DBR_LONG:
00540 for (unsigned int i=0; i<nelem; ++i) {
00541 *((dbr_char_t *) (PVDataL) + i ) = (dbr_char_t) val[i] ;
00542 }
00543 break;
00544 case DBR_DOUBLE:
00545 for (unsigned int i=0; i<nelem; ++i) {
00546 *((dbr_char_t *) (PVDataL) + i ) = (dbr_char_t) val[i] ;
00547 }
00548 break;
00549 case DBR_STRING:
00550 status=putString(_handle, (dbr_string_t *) val);
00551
00552 break;
00553 default:
00554 cout << "ERROR: " << __FILE__ << "/" << __LINE__ << "/" << __METHOD__ << endl;
00555 cafeStatus.report(ECAFE_INVALID_SWITCH_CASE);
00556 cout << "SWITCH STATMENT NOT MEANT FOR CAFE DATATYPE=" << _dbrType <<endl;
00557 cout << cafeDataTypeCode.message(_dbrType) << endl;
00558 cout << "ABORTING DATA CONVERTION TO LOCAL putBuffer" << endl;
00559 cout << "LIKELY THAT THE DATA_TYPE WAS NOT MADE KNOWN IN THE INPUT PARAMETERS" << endl;
00560
00561 return ECAFE_INVALID_SWITCH_CASE;
00562 break;
00563 }
00564 break;
00565
00566 case DBR_LONG:
00567 switch(_dbrType) {
00568 case DBR_SHORT:
00569 for (unsigned int i=0; i<nelem; ++i) {
00570 *((dbr_long_t *) (PVDataL) + i ) = (dbr_long_t) val[i] ;
00571 }
00572 break;
00573 case DBR_FLOAT:
00574 for (unsigned int i=0; i<nelem; ++i) {
00575 *((dbr_long_t *) (PVDataL) + i ) = (dbr_long_t) val[i] ;
00576 }
00577 break;
00578 case DBR_ENUM:
00579 for (unsigned int i=0; i<nelem; ++i) {
00580 *((dbr_long_t *) (PVDataL) + i ) = (dbr_long_t) val[i] ;
00581 }
00582 break;
00583 case DBR_CHAR:
00584 for (unsigned int i=0; i<nelem; ++i) {
00585 *((dbr_long_t *) (PVDataL) + i ) = (dbr_long_t) val[i] ;
00586 }
00587 break;
00588 case DBR_LONG:
00589 memcpy( PVDataL, val, sizeof(dbr_long_t)*nelem);
00590
00591 break;
00592 case DBR_DOUBLE:
00593 for (unsigned int i=0; i<nelem; ++i) {
00594 *((dbr_long_t *) (PVDataL) + i ) = (dbr_long_t) val[i] ;
00595 }
00596 break;
00597 case DBR_STRING:
00598 status=putString(_handle, (dbr_string_t *) val);
00599
00600 break;
00601 default:
00602 cout << "ERROR: " << __FILE__ << "/" << __LINE__ << "/" << __METHOD__ << endl;
00603 cafeStatus.report(ECAFE_INVALID_SWITCH_CASE);
00604 cout << "SWITCH STATMENT NOT MEANT FOR CAFE DATATYPE=" << _dbrType <<endl;
00605 cout << cafeDataTypeCode.message(_dbrType) << endl;
00606 cout << "ABORTING DATA CONVERTION TO LOCAL putBuffer" << endl;
00607 cout << "LIKELY THAT THE DATA_TYPE WAS NOT MADE KNOWN IN THE INPUT PARAMETERS" << endl;
00608
00609 return ECAFE_INVALID_SWITCH_CASE;
00610 break;
00611 }
00612 break;
00613
00614
00615 case DBR_DOUBLE:
00616
00617
00618
00619 switch(_dbrType) {
00620
00621 case DBR_SHORT:
00622 for (unsigned int i=0; i<nelem; ++i) {
00623 *((dbr_double_t *) (PVDataL) + i ) = (dbr_double_t) val[i] ;
00624 }
00625
00626 break;
00627
00628 case DBR_FLOAT:
00629 for (unsigned int i=0; i<nelem; ++i) {
00630 *((dbr_double_t *) (PVDataL) + i ) = (dbr_double_t) val[i] ;
00631 }
00632
00633
00634 break;
00635 case DBR_ENUM:
00636 for (unsigned int i=0; i<nelem; ++i) {
00637 *((dbr_double_t *) (PVDataL) + i ) = (dbr_double_t) val[i] ;
00638 }
00639 break;
00640 case DBR_CHAR:
00641 for (unsigned int i=0; i<nelem; ++i) {
00642 *((dbr_double_t *) (PVDataL) + i ) = (dbr_double_t) val[i] ;
00643 }
00644 break;
00645 case DBR_LONG:
00646 for (unsigned int i=0; i<nelem; ++i) {
00647 *((dbr_double_t *) (PVDataL) + i ) = (dbr_double_t) val[i] ;
00648 }
00649 break;
00650 case DBR_DOUBLE:
00651
00652 memcpy( PVDataL, val, sizeof(dbr_double_t)*nelem);
00653
00654
00655
00656 break;
00657 case DBR_STRING:
00658 status=putString(_handle, (dbr_string_t *) val);
00659
00660 break;
00661
00662 default:
00663 cout << "ERROR: " << __FILE__ << "/" << __LINE__ << "/" << __METHOD__ << endl;
00664 cafeStatus.report(ECAFE_INVALID_SWITCH_CASE);
00665 cout << "SWITCH STATMENT NOT MEANT FOR CAFE DATATYPE=" << _dbrType <<endl;
00666 cout << cafeDataTypeCode.message(_dbrType) << endl;
00667 cout << "ABORTING DATA CONVERTION TO LOCAL putBuffer" << endl;
00668 cout << "LIKELY THAT THE DATA_TYPE WAS NOT MADE KNOWN IN THE INPUT PARAMETERS" << endl;
00669
00670 return ECAFE_INVALID_SWITCH_CASE;
00671 break;
00672 }
00673 break;
00674 default:
00675 cout << "ERROR: " << __FILE__ << "/" << __LINE__ << "/" << __METHOD__ << endl;
00676 cafeStatus.report(ECAFE_INVALID_SWITCH_CASE);
00677 cout << "SWITCH STATMENT NOT MEANT FOR DATATYPE=" << dbrTypeRequest_DataBuffer <<endl;
00678 cout << cafeDataTypeCode.message(dbrTypeRequest_DataBuffer) << endl;
00679 cout << "ABORTING DATA CONVERTION TO LOCAL putBuffer" << endl;
00680 cout << "LIKELY THAT THE DATA_TYPE WAS NOT MADE KNOWN IN THE INPUT PARAMETERS" << endl;
00681
00682 return ECAFE_INVALID_SWITCH_CASE;
00683 break;
00684 }
00685 }
00686 else {
00687 cafeStatus.report(ECAFE_INVALID_HANDLE);
00688 return ECAFE_INVALID_HANDLE;
00689 }
00690
00691
00692
00693 return status;
00694
00695 #undef __METHOD__
00696 };
00697
00698
00699
00700
00708
00709
00710
00711 template <class CTYPE> int Transpose<CTYPE>::put( const unsigned int _handle,
00712 CAFE_DATATYPE_UNION_SEQ val, CAFE_DATATYPE cdt)
00713 {
00714 #define __METHOD__ "Transpose<CTYPE>::put()"
00715
00716 status=ICAFE_NORMAL;
00717
00718 cafeConduit_set_by_handle & handle_index=cs.get<by_handle>();
00719 cafeConduit_set_by_handle::iterator it_handle;
00720 it_handle = handle_index.find(_handle);
00721
00722 if (it_handle != handle_index.end()) {
00723
00724 PVDataL = (*it_handle).getPutBuffer ();
00725 nelem = (*it_handle).getChannelRequestMetaPrimitive().getNelem();
00726
00727
00728 dbrTypeRequest_DataBuffer = (*it_handle).getChannelRequestMetaPrimitive().getDbrDataType();
00729
00730
00731
00732
00733 dbr_ctrl_enum * dataEnum;
00734 dbr_short_t noStrings =0;
00735
00736
00737 switch (dbrTypeRequest_DataBuffer)
00738 {
00739 case DBR_STRING:
00740 switch(cdt){
00741 case CAFE_SHORT:
00742 for (unsigned int i=0; i<nelem; ++i) {
00743 sprintf(*((dbr_string_t *) (PVDataL) + i ),
00744 "%d", *reinterpret_cast<const short*>(&val[i].s));
00745 }
00746 break;
00747 case CAFE_FLOAT:
00748 for (unsigned int i=0; i<nelem; ++i) {
00749 sprintf(*((dbr_string_t *) (PVDataL) + i ) ,
00750 "%f", *reinterpret_cast<const float*>(&val[i].f));
00751 }
00752 break;
00753 case CAFE_ENUM:
00754 for (unsigned int i=0; i<nelem; ++i) {
00755 sprintf(*((dbr_string_t *) (PVDataL) + i ) ,
00756 "%u", *reinterpret_cast<const unsigned short*>(&val[i].us));
00757 }
00758 break;
00759 case CAFE_CHAR:
00760 for (unsigned int i=0; i<nelem; ++i) {
00761 sprintf(*((dbr_string_t *) (PVDataL) + i ) ,
00762 "%u", *reinterpret_cast<const char*>(&val[i].ch));
00763 }
00764 break;
00765 case CAFE_LONG:
00766 for (unsigned int i=0; i<nelem; ++i) {
00767 sprintf(*((dbr_string_t *) (PVDataL) + i ) ,
00768 "%d", *reinterpret_cast<const int*>(&val[i].l));
00769 }
00770 break;
00771 case CAFE_DOUBLE:
00772 for (unsigned int i=0; i<nelem; ++i) {
00773 sprintf(*((dbr_string_t *) (PVDataL) + i ) ,
00774 "%.15lf", *reinterpret_cast<const double*>(&val[i].d));
00775 }
00776 break;
00777 case CAFE_STRING:
00778 for (unsigned int i=0; i<nelem; ++i) {
00779
00780 sprintf(*((dbr_string_t *) (PVDataL) + i ) ,
00781 "%s", *reinterpret_cast<char * const *>(&val[i].str));
00782
00783 }
00784 break;
00785 default:
00786 cout << "ERROR: " << __FILE__ << "/" << __LINE__ << "/" << __METHOD__ << endl;
00787 cafeStatus.report(ECAFE_INVALID_SWITCH_CASE);
00788 cout << "SWITCH STATMENT NOT MEANT FOR CAFE DATATYPE=" << cdt <<endl;
00789 cout << cafeDataTypeCode.message(cdt) << endl;
00790 cout << "ABORTING DATA CONVERTION TO LOCAL putBuffer" << endl;
00791 cout << "LIKELY THAT THE DATA_TYPE WAS NOT MADE KNOWN IN THE INPUT PARAMETERS" << endl;
00792
00793 return ECAFE_INVALID_SWITCH_CASE;
00794 break;
00795 }
00796
00797 break;
00798 case DBR_ENUM:
00799
00800
00801
00802 dataEnum = (dbr_ctrl_enum *) (*it_handle).getCtrlBuffer();
00803
00804
00805 noStrings = ((struct dbr_ctrl_enum *) dataEnum)->no_str;
00806
00807 memcpy( stig, &(((struct dbr_ctrl_enum *) dataEnum)->strs), sizeof(stig )) ;
00808
00809
00810 switch(cdt) {
00811
00812 case CAFE_SHORT:
00813 for (unsigned int i=0; i<nelem; ++i) {
00814 *((CTYPE *) (PVDataL) + i ) = (CTYPE) val[i].s ;
00815 if ( val[i].s < 0 || (dbr_enum_t) val[i].s >= (dbr_enum_t) noStrings) {
00816 status=ECAFE_INVALID_ENUM_INDEX;
00817 }
00818 }
00819
00820 break;
00821
00822 case CAFE_FLOAT:
00823 for (unsigned int i=0; i<nelem; ++i) {
00824 *((CTYPE *) (PVDataL) + i ) = (CTYPE) val[i].f ;
00825 if ( val[i].f < 0 || (dbr_enum_t) val[i].f >= (dbr_enum_t) noStrings) {
00826 status=ECAFE_INVALID_ENUM_INDEX;
00827 }
00828 }
00829
00830
00831 break;
00832 case CAFE_ENUM:
00833 for (unsigned int i=0; i<nelem; ++i) {
00834 *((CTYPE *) (PVDataL) + i ) = (CTYPE) val[i].us ;
00835 if ( (dbr_enum_t) val[i].us >= (dbr_enum_t) noStrings) {
00836 status=ECAFE_INVALID_ENUM_INDEX;
00837 }
00838 }
00839 break;
00840 case CAFE_CHAR:
00841 for (unsigned int i=0; i<nelem; ++i) {
00842 *((CTYPE *) (PVDataL) + i ) = (CTYPE) val[i].ch ;
00843 if ( (dbr_enum_t) val[i].ch >= (dbr_enum_t) noStrings) {
00844 status=ECAFE_INVALID_ENUM_INDEX;
00845 }
00846 }
00847 break;
00848 case CAFE_LONG:
00849 for (unsigned int i=0; i<nelem; ++i) {
00850 *((CTYPE *) (PVDataL) + i ) = (CTYPE) val[i].l ;
00851 if ( val[i].l < 0 || (dbr_enum_t) val[i].l >= (dbr_enum_t)noStrings) {
00852 status=ECAFE_INVALID_ENUM_INDEX;
00853 }
00854 }
00855 break;
00856 case CAFE_DOUBLE:
00857 for (unsigned int i=0; i<nelem; ++i) {
00858 *((CTYPE *) (PVDataL) + i ) = (CTYPE) val[i].d ;
00859 if ( val[i].d < 0 || (dbr_enum_t) val[i].d >= (dbr_enum_t)noStrings) {
00860 status=ECAFE_INVALID_ENUM_INDEX;
00861 }
00862 }
00863
00864
00865 break;
00866 case CAFE_STRING:
00867 status=putString(_handle, (dbr_string_t *) val);
00868
00869 break;
00870
00871 default:
00872 cout << "ERROR: " << __FILE__ << "/" << __LINE__ << "/" << __METHOD__ << endl;
00873 cafeStatus.report(ECAFE_INVALID_SWITCH_CASE);
00874 cout << "SWITCH STATMENT NOT MEANT FOR CAFE DATATYPE=" << cdt <<endl;
00875 cout << cafeDataTypeCode.message(cdt) << endl;
00876 cout << "ABORTING DATA CONVERTION TO LOCAL putBuffer" << endl;
00877 cout << "LIKELY THAT THE DATA_TYPE WAS NOT MADE KNOWN IN THE INPUT PARAMETERS" << endl;
00878
00879 return ECAFE_INVALID_SWITCH_CASE;
00880 break;
00881 }
00882
00883
00884 break;
00885
00886 case DBR_SHORT:
00887 case DBR_FLOAT:
00888
00889
00890 case DBR_CHAR:
00891 case DBR_LONG:
00892 case DBR_DOUBLE:
00893
00894 switch(cdt) {
00895
00896 case CAFE_SHORT:
00897 for (unsigned int i=0; i<nelem; ++i) {
00898 *((CTYPE *) (PVDataL) + i ) = (CTYPE) val[i].s ;
00899 }
00900
00901 break;
00902
00903 case CAFE_FLOAT:
00904 for (unsigned int i=0; i<nelem; ++i) {
00905 *((CTYPE *) (PVDataL) + i ) = (CTYPE) val[i].f ;
00906 }
00907
00908
00909 break;
00910 case CAFE_ENUM:
00911 for (unsigned int i=0; i<nelem; ++i) {
00912 *((CTYPE *) (PVDataL) + i ) = (CTYPE) val[i].us ;
00913 }
00914 break;
00915 case CAFE_CHAR:
00916 for (unsigned int i=0; i<nelem; ++i) {
00917 *((CTYPE *) (PVDataL) + i ) = (CTYPE) val[i].ch ;
00918 }
00919 break;
00920 case CAFE_LONG:
00921 for (unsigned int i=0; i<nelem; ++i) {
00922 *((CTYPE *) (PVDataL) + i ) = (CTYPE) val[i].l ;
00923 }
00924 break;
00925 case CAFE_DOUBLE:
00926 for (unsigned int i=0; i<nelem; ++i) {
00927 *((CTYPE *) (PVDataL) + i ) = (CTYPE) val[i].d ;
00928 }
00929
00930 break;
00931 case CAFE_STRING:
00932 status=putString(_handle, (dbr_string_t *) val);
00933
00934 break;
00935
00936 default:
00937 cout << "ERROR: " << __FILE__ << "/" << __LINE__ << "/" << __METHOD__ << endl;
00938 cafeStatus.report(ECAFE_INVALID_SWITCH_CASE);
00939 cout << "SWITCH STATMENT NOT MEANT FOR CAFE DATATYPE=" << cdt <<endl;
00940 cout << cafeDataTypeCode.message(cdt) << endl;
00941 cout << "ABORTING DATA CONVERTION TO LOCAL putBuffer" << endl;
00942 cout << "LIKELY THAT THE DATA_TYPE WAS NOT MADE KNOWN IN THE INPUT PARAMETERS" << endl;
00943
00944 return ECAFE_INVALID_SWITCH_CASE;
00945 break;
00946 }
00947 break;
00948 default:
00949 cout << "ERROR: " << __FILE__ << "/" << __LINE__ << "/" << __METHOD__ << endl;
00950 cafeStatus.report(ECAFE_INVALID_SWITCH_CASE);
00951 cout << "SWITCH STATMENT NOT MEANT FOR DATATYPE=" << dbrTypeRequest_DataBuffer <<endl;
00952 cout << cafeDataTypeCode.message(dbrTypeRequest_DataBuffer) << endl;
00953 cout << "ABORTING DATA CONVERTION TO LOCAL putBuffer" << endl;
00954 cout << "LIKELY THAT THE DATA_TYPE WAS NOT MADE KNOWN IN THE INPUT PARAMETERS" << endl;
00955
00956
00957 return ECAFE_INVALID_SWITCH_CASE;
00958 break;
00959 }
00960 }
00961 else {
00962 cafeStatus.report(ECAFE_INVALID_HANDLE);
00963 return ECAFE_INVALID_HANDLE;
00964 }
00965
00966 return status;
00967 #undef __METHOD__
00968 };
00969
00970
00971
00972
00973
00981 template <class CTYPE> int Transpose<CTYPE>::putString
00982 (const unsigned int _handle, dbr_string_t * val)
00983 {
00984 #define __METHOD__ "Transpose<CTYPE>::putString"
00985
00986 cafeConduit_set_by_handle & handle_index=cs.get<by_handle>();
00987 cafeConduit_set_by_handle::iterator it_handle;
00988 it_handle = handle_index.find(_handle);
00989
00990 if (it_handle != handle_index.end()) {
00991
00992 PVDataL = (*it_handle).getPutBuffer ();
00993 nelem = (*it_handle).getChannelRequestMetaPrimitive().getNelem();
00994
00995 dbrTypeRequest_DataBuffer = (*it_handle).getChannelRequestMetaPrimitive().getDbrDataType();
00996
00997 dbr_ctrl_enum * dataEnum;
00998 dbr_short_t noStrings =0;
00999
01000 bool allStringsAreValid=true;
01001
01002
01003
01004 istringstream ss;
01005
01006 switch(dbrTypeRequest_DataBuffer) {
01007
01008 case DBR_STRING:
01009
01010
01011 for (unsigned int i=0; i<nelem; ++i) {
01012 strcpy( *((dbr_string_t *) (PVDataL) +i), val[i]);
01013 }
01014 break;
01015
01016 case DBR_SHORT:
01017 for (unsigned int i=0; i<nelem; ++i) {
01018 dbr_short_t s=0;
01019 ss.clear();
01020 ss.str(val[i]);
01021 ss>>s;
01022
01023 if ( !ss.fail()) {
01024 *((dbr_short_t *) (PVDataL) + i ) = s;
01025 }
01026 else {
01027 cout << __METHOD__ << __LINE__ << endl;
01028 cout << "***WARNING*** NO STRING TO DBR_SHORT CONVERSION for ELEMENT " << i
01029 << " of " << nelem << " !! " << endl;
01030 cout << "***WARNING*** COULD NOT CONVERT: ";
01031 cout << val[i];
01032 cout << " TO SHORT; PUT REQUEST NOT MADE!" << endl;
01033
01034 allStringsAreValid=false;
01035 }
01036 }
01037 break;
01038
01039 case DBR_FLOAT:
01040 for (unsigned int i=0; i<nelem; ++i) {
01041 dbr_float_t f=0;
01042 ss.clear();
01043 ss.str(val[i]);
01044 ss>>f;
01045
01046 if ( !ss.fail()) {
01047 *((dbr_float_t *) (PVDataL) + i ) = f;
01048 }
01049 else {
01050 cout << __METHOD__ << __LINE__ << endl;
01051 cout << "***WARNING*** NO STRING TO DBR_FLOAT CONVERSION for ELEMENT " << i << " of " << nelem << " !! " << endl;
01052 cout << "***WARNING*** COULD NOT CONVERT: ";
01053 cout << val[i];
01054 cout << " TO FLOAT; PUT REQUEST NOT MADE!" << endl;
01055 allStringsAreValid=false;
01056 }
01057 }
01058 break;
01059
01060 case DBR_ENUM:
01061
01062 dataEnum = (dbr_ctrl_enum *) (*it_handle).getCtrlBuffer();
01063
01064
01065 noStrings = ((struct dbr_ctrl_enum *) dataEnum)->no_str;
01066
01067 memcpy( stig, &(((struct dbr_ctrl_enum *) dataEnum)->strs), sizeof(stig )) ;
01068
01069
01070 for (unsigned int i=0; i<nelem; ++i) {
01071 dbr_string_t a;
01072
01073
01074
01075 char *b = (char *) val[i];
01076 char *c;
01077
01078 c = b;
01079 while (c != '\0' && *c == ' ') {
01080 c++;
01081 }
01082 b = c;
01083
01084
01085 c = b + strlen (b) - 1;
01086 while (c >= b)
01087 {
01088 if (*c == ' ') {
01089 *c = '\0';
01090
01091 }
01092 else {
01093 break;
01094 }
01095 c--;
01096 }
01097
01098 sprintf(a, "%s", b);
01099
01100 bool isValidString=false;
01101 for (int j=0; j<noStrings; ++j) {
01102
01103 if (strcmp((char *)a, stig[j] ) ==0) {
01104
01105 dbr_enum_t us= (unsigned short) j;
01106 *((dbr_enum_t *) (PVDataL) + i ) = us;
01107 isValidString=true;
01108
01109 break;
01110 }
01111 }
01112
01113
01114
01115 if (!isValidString) {
01116
01117 bool isValidStringAnew=false;
01118
01119 dbr_enum_t us=0;
01120 ss.clear();
01121 ss.str(a);
01122 ss>>us;
01123
01124
01125 if ( !ss.fail()) {
01126 if (us==0 || (us>0 && us <noStrings)) {
01127 *((dbr_enum_t *) (PVDataL) + i ) = us;
01128 isValidStringAnew=true;
01129 }
01130 else {
01131 status=ECAFE_INVALID_ENUM_INDEX;
01132 }
01133 }
01134
01135 if (!isValidStringAnew) {
01136
01137 cout << __METHOD__ << __LINE__ << endl;
01138 cout << "***WARNING*** NO STRING TO DBR_ENUM MATCHING for ELEMENT " << i << " of " << nelem << " !! " << endl;
01139 cout << "***WARNING*** COULD NOT CONVERT: '";
01140 cout << a;
01141 cout << "' TO A VALID ENUM; PUT REQUEST NOT MADE!" << endl;
01142 cout << "VALID STRING [ENUM] OPTIONS ARE: " << endl;
01143
01144
01145 for (dbr_short_t ij=0; ij<noStrings; ++ij) {
01146 cout << "'" << stig[ij] << "' " << "[" << ij << "]" << "; ";
01147 }
01148 cout << endl;
01149
01150
01151 allStringsAreValid=false;
01152 }
01153
01154 }
01155
01156 }
01157
01158
01159
01160 break;
01161
01162 case DBR_CHAR:
01163 for (unsigned int i=0; i<nelem; ++i) {
01164 dbr_char_t ch=0;
01165 ss.clear();
01166 ss.str(val[i]);
01167 ss>>ch;
01168
01169 if ( !ss.fail()) {
01170 *((dbr_char_t *) (PVDataL) + i ) = ch;
01171 }
01172 else {
01173 cout << __METHOD__ << __LINE__ << endl;
01174 cout << "***WARNING*** NO STRING TO DBR_CHAR CONVERSION for ELEMENT " << i << " of " << nelem << " !! " << endl;
01175 cout << "***WARNING*** COULD NOT CONVERT: ";
01176 cout << val[i];
01177 cout << " TO UNSIGNED CHAR; PUT REQUEST NOT MADE!" << endl;
01178 allStringsAreValid=false;
01179 }
01180 }
01181 break;
01182
01183 case DBR_LONG:
01184 for (unsigned int i=0; i<nelem; ++i) {
01185 dbr_long_t l=0;
01186 ss.clear();
01187 ss.str(val[i]);
01188 ss>>l;
01189
01190 if ( !ss.fail()) {
01191 *((dbr_long_t *) (PVDataL) + i ) = l;
01192 }
01193 else {
01194 cout << __METHOD__ << __LINE__ << endl;
01195 cout << "***WARNING*** NO STRING TO DBR_LONG CONVERSION for ELEMENT " << i << " of " << nelem << " !! " << endl;
01196 cout << "***WARNING*** COULD NOT CONVERT: ";
01197 cout << val[i];
01198 cout << " TO LONG; PUT REQUEST NOT MADE!" << endl;
01199
01200 allStringsAreValid=false;
01201 }
01202 }
01203 break;
01204
01205 case DBR_DOUBLE:
01206 for (unsigned int i=0; i<nelem; ++i) {
01207 dbr_double_t d=0;
01208 ss.clear();
01209 ss.str(val[i]);
01210 ss>>d;
01211
01212 if ( !ss.fail()) {
01213 *((dbr_double_t *) (PVDataL) + i ) = d;
01214 }
01215 else {
01216 cout << __METHOD__ << __LINE__ << endl;
01217 cout << "***WARNING*** NO STRING TO DBR_DOUBLE CONVERSION for ELEMENT " << i << " of " << nelem << " !! " << endl;
01218 cout << "***WARNING*** COULD NOT CONVERT: ";
01219 cout << val[i];
01220 cout << " TO DOUBLE; PUT REQUEST NOT MADE!" << endl;
01221
01222 allStringsAreValid=false;
01223 }
01224
01225 }
01226 break;
01227 }
01228
01229
01230 if(!allStringsAreValid) {
01231 if (status==ECAFE_INVALID_ENUM_INDEX) {return status;}
01232 return ECAFE_NO_CONVERT;}
01233 else {return ICAFE_NORMAL;}
01234
01235 }
01236 else {
01237 cafeStatus.report(ECAFE_INVALID_HANDLE);
01238 return ECAFE_INVALID_HANDLE;
01239 }
01240 return ICAFE_NORMAL;
01241
01242 #undef __METHOD__
01243 }
01244
01245
01246
01258 template <class CTYPE> int Transpose<CTYPE>::get(
01259 const unsigned int _handle, CTYPE * val,
01260 dbr_short_t &alarmStatus, dbr_short_t &alarmSeverity, epicsTimeStamp &ts, bool isCacheRequest)
01261 {
01262 #define __METHOD__ "Transpose<CTYPE>::get()"
01263
01264 cafeConduit_set_by_handle & handle_index=cs.get<by_handle>();
01265 cafeConduit_set_by_handle::iterator it_handle;
01266 it_handle = handle_index.find(_handle);
01267
01268 if (it_handle != handle_index.end()) {
01269
01270 PVDataL = (*it_handle).getDataBuffer();
01271 offset = (*it_handle).getChannelRequestMetaDataClient().getOffset();
01272
01273 if(isCacheRequest) {
01274 nelem = (*it_handle).getChannelRequestMetaData().getNelemCache()-(*it_handle).getChannelRequestMetaData().getOffset();
01275 }
01276 else {
01277 nelem = (*it_handle).getChannelRequestMetaData().getNelem()-offset;
01278
01279
01280
01281
01282 }
01283
01284 if (nelem <=0) {
01285 cout << __FILE__ << "//" << __LINE__ << "//" << __METHOD__ << endl;
01286 cout << "Something funny with the offset; hence will read last element only!"<< endl;
01287 cout << "Changing offset from=" << offset;
01288
01289 offset = (*it_handle).getChannelRequestMetaData().getNelem()-1;
01290 if(isCacheRequest) {
01291 nelem = (*it_handle).getChannelRequestMetaData().getNelemCache()-(*it_handle).getChannelRequestMetaData().getOffset();
01292 }
01293 else {
01294 nelem = (*it_handle).getChannelRequestMetaData().getNelem()-offset;
01295 }
01296
01297 cout << " to=" << offset << endl;
01298 }
01299
01300 dbrTypeRequest_DataBuffer = (*it_handle).getChannelRequestMetaData().getDbrDataType();
01301 _dataTypeClient = (*it_handle).getChannelRequestMetaDataClient().getDataType();
01302
01303
01304
01305
01306 ts.secPastEpoch=0;
01307 ts.nsec =0;
01308 alarmStatus =-1;
01309 alarmSeverity =-1;
01310
01311
01312 if (_dataTypeClient < DBR_STRING || _dataTypeClient > DBR_DOUBLE) {
01313 cout << __FILE__ << "/" << __LINE__ << "/" << __METHOD__ << endl;
01314 cout << "Datatype requested " << dbr_type_to_text(_dataTypeClient)
01315 << " is not within allowed range: " << endl;
01316 cout << "DBR_STRING <= dataType <= DBR_DOUBLE" << endl;
01317 cout << "CAFE ERROR: ECAFE_INVALID_SWITCH_CASE" << endl;
01318 return ECAFE_INVALID_SWITCH_CASE;
01319 }
01320
01321
01322
01323
01324 switch (dbrTypeRequest_DataBuffer)
01325 {
01326 case DBR_CHAR:
01327 switch(_dataTypeClient)
01328 {
01329 case DBR_CHAR:
01330 memcpy( val, &(&((PVDataL)->charval))[offset], sizeof(dbr_char_t)*nelem);
01331 break;
01332
01333 default:
01334 for (unsigned int i=0; i<nelem; ++i) {
01335 val[i] = (CTYPE) (*(&((PVDataL)->charval)+i+offset));
01336 }
01337 break;
01338 }
01339 break;
01340
01341 case DBR_FLOAT:
01342 switch(_dataTypeClient)
01343 {
01344 case DBR_FLOAT:
01345 memcpy( val, &(&((PVDataL)->fltval))[offset], sizeof(dbr_float_t)*nelem);
01346 break;
01347 default:
01348 for (unsigned int i=0; i<nelem; ++i){
01349 val[i] = (CTYPE) (*(&((PVDataL)->fltval)+i+offset));
01350 }
01351 break;
01352 }
01353
01354 break;
01355
01356 case DBR_DOUBLE:
01357 switch(_dataTypeClient)
01358 {
01359 case DBR_DOUBLE:
01360 memcpy( val, &(&((PVDataL)->doubleval))[offset], sizeof(dbr_double_t)*nelem);
01361 break;
01362 default:
01363 for (unsigned int i=0; i<nelem; ++i) {
01364 val[i] = (CTYPE) (*(&((PVDataL)->doubleval)+i+offset));
01365 }
01366 break;
01367 }
01368 break;
01369
01370 case DBR_SHORT:
01371 switch(_dataTypeClient)
01372 {
01373 case DBR_SHORT:
01374 memcpy( val, &(&((PVDataL)->shrtval))[offset], sizeof(dbr_short_t)*nelem);
01375 break;
01376 default:
01377 for (unsigned int i=0; i<nelem; ++i) {
01378 val[i] = (CTYPE) (*(&((PVDataL)->shrtval)+i+offset));
01379 }
01380 break;
01381 }
01382 break;
01383
01384 case DBR_LONG:
01385 switch(_dataTypeClient)
01386 {
01387 case DBR_LONG:
01388 memcpy( val, &(&((PVDataL)->longval))[offset], sizeof(dbr_long_t)*nelem);
01389 break;
01390 default:
01391 for (unsigned int i=0; i<nelem; ++i) {
01392 val[i] = (CTYPE) (*(&((PVDataL)->longval)+i+offset));
01393 }
01394 break;
01395 }
01396 break;
01397
01398 case DBR_ENUM:
01399 switch(_dataTypeClient)
01400 {
01401 case DBR_ENUM:
01402 memcpy( val, &(&((PVDataL)->enmval))[offset], sizeof(dbr_enum_t)*nelem);
01403 break;
01404 default:
01405 for (unsigned int i=0; i<nelem; ++i) {
01406 val[i] = (CTYPE) (*(&((PVDataL)->enmval)+i+offset));
01407 }
01408 break;
01409 }
01410 break;
01411
01412 case DBR_STRING:
01413 switch(_dataTypeClient)
01414 {
01415 case DBR_STRING:
01416 memcpy( val, &(&((PVDataL)->strval))[offset], sizeof(dbr_string_t)*nelem);
01417 break;
01418
01419 case DBR_SHORT:
01420 case DBR_LONG:
01421 case DBR_ENUM:
01422 case DBR_CHAR:
01423 for (unsigned int i=0; i<nelem; ++i) {
01424 val[i]= (CTYPE) strtol( (*(&((PVDataL)->strval)+i+offset)), NULL, 0);
01425 }
01426 break;
01427 case DBR_FLOAT:
01428 case DBR_DOUBLE:
01429 default:
01430
01431 for (unsigned int i=0; i<nelem; ++i) {
01432 val[i]= (CTYPE) strtod( (*(&((PVDataL)->strval)+i+offset)), NULL);
01433 }
01434 break;
01435 }
01436 break;
01437
01438 case DBR_STS_CHAR:
01439 switch(_dataTypeClient)
01440 {
01441 case DBR_CHAR:
01442 memcpy( val, &(&((PVDataL)->schrval.value))[offset], sizeof(dbr_char_t)*nelem);
01443 break;
01444 default:
01445 for (unsigned int i=0; i<nelem; ++i) {
01446 val[i] = (CTYPE) (*(&((PVDataL)->schrval.value)+i+offset));
01447 }
01448 break;
01449 }
01450 alarmStatus = ((struct dbr_sts_char *) PVDataL)->status;
01451 alarmSeverity = ((struct dbr_sts_char *) PVDataL)->severity;
01452 break;
01453
01454 case DBR_STS_FLOAT:
01455 switch(_dataTypeClient)
01456 {
01457 case DBR_FLOAT:
01458 memcpy( val, &(&((PVDataL)->sfltval.value))[offset], sizeof(dbr_float_t)*nelem);
01459 break;
01460 default:
01461 for (unsigned int i=0; i<nelem; ++i) {
01462 val[i] = (CTYPE) (*(&((PVDataL)->sfltval.value)+i+offset));
01463 }
01464 break;
01465 }
01466 alarmStatus = ((struct dbr_sts_float *) PVDataL)->status;
01467 alarmSeverity = ((struct dbr_sts_float *) PVDataL)->severity;
01468 break;
01469
01470 case DBR_STS_DOUBLE:
01471 switch(_dataTypeClient)
01472 {
01473 case DBR_DOUBLE:
01474 memcpy( val, &(&((PVDataL)->sdblval.value))[offset], sizeof(dbr_double_t)*nelem);
01475 break;
01476 default:
01477 for (unsigned int i=0; i<nelem; ++i) {
01478 val[i] = (CTYPE) (*(&((PVDataL)->sdblval.value)+i+offset));
01479 }
01480 break;
01481 }
01482 alarmStatus = ((struct dbr_sts_double *) PVDataL)->status;
01483 alarmSeverity = ((struct dbr_sts_double *) PVDataL)->severity;
01484 break;
01485
01486 case DBR_STS_SHORT:
01487 switch(_dataTypeClient)
01488 {
01489 case DBR_SHORT:
01490 memcpy( val, &(&((PVDataL)->sshrtval.value))[offset], sizeof(dbr_short_t)*nelem);
01491 break;
01492 default:
01493 for (unsigned int i=0; i<nelem; ++i) {
01494 val[i] = (CTYPE) (*(&((PVDataL)->sshrtval.value)+i+offset));
01495 }
01496 break;
01497 }
01498 alarmStatus = ((struct dbr_sts_short *) PVDataL)->status;
01499 alarmSeverity = ((struct dbr_sts_short *) PVDataL)->severity;
01500 break;
01501
01502 case DBR_STS_LONG:
01503 switch(_dataTypeClient)
01504 {
01505 case DBR_LONG:
01506 memcpy( val, &(&((PVDataL)->slngval.value))[offset], sizeof(dbr_long_t)*nelem);
01507 break;
01508 default:
01509 for (unsigned int i=0; i<nelem; ++i) {
01510 val[i] = (CTYPE) (*(&((PVDataL)->slngval.value)+i+offset));
01511 }
01512 break;
01513 }
01514 alarmStatus = ((struct dbr_sts_long *) PVDataL)->status;
01515 alarmSeverity = ((struct dbr_sts_long *) PVDataL)->severity;
01516 break;
01517
01518 case DBR_STS_ENUM:
01519 switch(_dataTypeClient)
01520 {
01521 case DBR_ENUM:
01522 memcpy( val, &(&((PVDataL)->senmval.value))[offset], sizeof(dbr_enum_t)*nelem);
01523 break;
01524 default:
01525 for (unsigned int i=0; i<nelem; ++i) {
01526 val[i] = (CTYPE) (*(&((PVDataL)->senmval.value)+i+offset));
01527 }
01528 break;
01529 }
01530 alarmStatus = ((struct dbr_sts_enum *) PVDataL)->status;
01531 alarmSeverity = ((struct dbr_sts_enum *) PVDataL)->severity;
01532 break;
01533
01534 case DBR_STS_STRING:
01535 switch(_dataTypeClient)
01536 {
01537 case DBR_STRING:
01538 memcpy( val, &(&((PVDataL)->sstrval.value))[offset], sizeof(dbr_string_t)*nelem);
01539 break;
01540 case DBR_SHORT:
01541 case DBR_LONG:
01542 case DBR_ENUM:
01543 case DBR_CHAR:
01544 for (unsigned int i=0; i<nelem; ++i) {
01545 val[i] = (CTYPE) strtol( (*(&((PVDataL)->sstrval.value)+i+offset)), NULL, 0);
01546 }
01547 break;
01548 case DBR_FLOAT:
01549 case DBR_DOUBLE:
01550 default:
01551 for (unsigned int i=0; i<nelem; ++i) {
01552 val[i] = (CTYPE) strtod( (*(&((PVDataL)->sstrval.value)+i+offset)), NULL);
01553 }
01554 break;
01555 }
01556 alarmStatus = ((struct dbr_sts_string *) PVDataL)->status;
01557 alarmSeverity = ((struct dbr_sts_string *) PVDataL)->severity;
01558 break;
01559
01560 case DBR_TIME_CHAR:
01561 switch(_dataTypeClient)
01562 {
01563 case DBR_CHAR:
01564 memcpy( val, &(&((PVDataL)->tchrval.value))[offset], sizeof(dbr_char_t)*nelem);
01565 break;
01566 case DBR_SHORT:
01567 case DBR_LONG:
01568 case DBR_ENUM:
01569 case DBR_FLOAT:
01570 case DBR_DOUBLE:
01571 default:
01572 for (unsigned int i=0; i<nelem; ++i) {
01573 val[i] = (CTYPE) (*(&((PVDataL)->tchrval.value)+i+offset));
01574 }
01575 break;
01576
01577
01578
01579 }
01580 ts = ((struct dbr_time_char *) PVDataL)->stamp;
01581 alarmStatus = ((struct dbr_time_char *) PVDataL)->status;
01582 alarmSeverity = ((struct dbr_time_char *) PVDataL)->severity;
01583 break;
01584
01585 case DBR_TIME_FLOAT:
01586 switch(_dataTypeClient)
01587 {
01588 case DBR_FLOAT:
01589 memcpy( val, &(&((PVDataL)->tfltval.value))[offset], sizeof(dbr_float_t)*nelem);
01590 break;
01591 case DBR_SHORT:
01592 case DBR_LONG:
01593 case DBR_ENUM:
01594 case DBR_CHAR:
01595 case DBR_DOUBLE:
01596 default:
01597 for (unsigned int i=0; i<nelem; ++i) {
01598 val[i] = (CTYPE) (*(&((PVDataL)->tfltval.value)+i+offset));
01599 }
01600 break;
01601 }
01602 ts = ((struct dbr_time_float *) PVDataL)->stamp;
01603 alarmStatus = ((struct dbr_time_float *) PVDataL)->status;
01604 alarmSeverity = ((struct dbr_time_float *) PVDataL)->severity;
01605 break;
01606
01607 case DBR_TIME_DOUBLE:
01608 switch(_dataTypeClient)
01609 {
01610 case DBR_DOUBLE:
01611 memcpy( val, &(&((PVDataL)->tdblval.value))[offset], sizeof(dbr_double_t)*nelem);
01612 break;
01613 case DBR_SHORT:
01614 case DBR_LONG:
01615 case DBR_ENUM:
01616 case DBR_CHAR:
01617 case DBR_FLOAT:
01618 default:
01619 for (unsigned int i=0; i<nelem; ++i) {
01620 val[i] = (CTYPE) (*(&((PVDataL)->tdblval.value)+i+offset));
01621 }
01622 break;
01623 }
01624 ts = ((struct dbr_time_double *) PVDataL)->stamp;
01625 alarmStatus = ((struct dbr_time_double *) PVDataL)->status;
01626 alarmSeverity = ((struct dbr_time_double *) PVDataL)->severity;
01627
01628 break;
01629
01630 case DBR_TIME_SHORT:
01631 switch(_dataTypeClient)
01632 {
01633 case DBR_SHORT:
01634 memcpy( val, &(&((PVDataL)->tshrtval.value))[offset], sizeof(dbr_short_t)*nelem);
01635 break;
01636 case DBR_DOUBLE:
01637 case DBR_LONG:
01638 case DBR_ENUM:
01639 case DBR_CHAR:
01640 case DBR_FLOAT:
01641 default:
01642 for (unsigned int i=0; i<nelem; ++i) {
01643 val[i] = (CTYPE) (*(&((PVDataL)->tshrtval.value)+i+offset));
01644 }
01645 break;
01646
01647
01648 }
01649 ts = ((struct dbr_time_short *) PVDataL)->stamp;
01650 alarmStatus = ((struct dbr_time_short *) PVDataL)->status;
01651 alarmSeverity = ((struct dbr_time_short *) PVDataL)->severity;
01652 break;
01653
01654 case DBR_TIME_LONG:
01655 switch(_dataTypeClient){
01656 case DBR_LONG:
01657 memcpy( val, &(&((PVDataL)->tlngval.value))[offset], sizeof(dbr_long_t)*nelem);
01658 break;
01659 case DBR_DOUBLE:
01660 case DBR_SHORT:
01661 case DBR_ENUM:
01662 case DBR_CHAR:
01663 case DBR_FLOAT:
01664 default:
01665 for (unsigned int i=0; i<nelem; ++i) {
01666 val[i] = (CTYPE) (*(&((PVDataL)->tlngval.value)+i+offset));
01667 }
01668 break;
01669
01670
01671
01672 }
01673 ts = ((struct dbr_time_long *) PVDataL)->stamp;
01674 alarmStatus = ((struct dbr_time_long *) PVDataL)->status;
01675 alarmSeverity = ((struct dbr_time_long *) PVDataL)->severity;
01676 break;
01677
01678 case DBR_TIME_ENUM:
01679 switch(_dataTypeClient)
01680 {
01681 case DBR_ENUM:
01682 memcpy( val, &(&((PVDataL)->tenmval.value))[offset], sizeof(dbr_enum_t)*nelem);
01683 break;
01684 case DBR_DOUBLE:
01685 case DBR_SHORT:
01686 case DBR_LONG:
01687 case DBR_CHAR:
01688 case DBR_FLOAT:
01689 default:
01690 for (unsigned int i=0; i<nelem; ++i) {
01691 val[i] = (CTYPE) (*(&((PVDataL)->tenmval.value)+i+offset));
01692 }
01693 break;
01694
01695
01696
01697 }
01698 ts = ((struct dbr_time_enum *) PVDataL)->stamp;
01699 alarmStatus = ((struct dbr_time_enum *) PVDataL)->status;
01700 alarmSeverity = ((struct dbr_time_enum *) PVDataL)->severity;
01701 break;
01702
01703
01704 case DBR_TIME_STRING:
01705 default:
01706 switch(_dataTypeClient){
01707 case DBR_STRING:
01708 memcpy( val, &(&((PVDataL)->strval))[offset], sizeof(dbr_string_t)*nelem);
01709 break;
01710 case DBR_SHORT:
01711 case DBR_LONG:
01712 case DBR_ENUM:
01713 case DBR_CHAR:
01714 for (unsigned int i=0; i<nelem; ++i) {
01715 val[i]= (CTYPE) strtol( (*(&((PVDataL)->tstrval.value)+i+offset)), NULL, 0);
01716 }
01717 break;
01718 case DBR_FLOAT:
01719 case DBR_DOUBLE:
01720 default:
01721 for (unsigned int i=0; i<nelem; ++i) {
01722 val[i]= (CTYPE) strtod( (*(&((PVDataL)->tstrval.value)+i+offset)), NULL);
01723 }
01724 break;
01725 }
01726 ts = ((struct dbr_time_string *) PVDataL)->stamp;
01727 alarmStatus = ((struct dbr_time_string *) PVDataL)->status;
01728 alarmSeverity = ((struct dbr_time_string *) PVDataL)->severity;
01729 break;
01730 }
01731
01732
01733
01734
01735
01736 if(!isCacheRequest) {
01737 handleHelper.setSTS(_handle, alarmStatus, alarmSeverity, ts);
01738 }
01739
01740 }
01741 else {
01742 cafeStatus.report(ECAFE_INVALID_HANDLE);
01743 return ECAFE_INVALID_HANDLE;
01744 }
01745
01746 return ICAFE_NORMAL;
01747
01748
01749 #undef __METHOD__
01750 }
01751
01752
01775 template <class CTYPE> int Transpose<CTYPE>::getCtrl (
01776
01777
01778
01779 const unsigned int _handle, CTYPE * val,
01780 dbr_short_t &alarmStatus, dbr_short_t &alarmSeverity, dbr_short_t &precision,
01781 CTYPE &RISC_pad,
01782 CTYPE &upperDispLimit, CTYPE &lowerDispLimit,
01783 CTYPE &upperAlarmLimit, CTYPE &upperWarningLimit,
01784 CTYPE &lowerWarningLimit, CTYPE &lowerAlarmLimit,
01785 CTYPE &upperCtrlLimit, CTYPE &lowerCtrlLimit,
01786 char units[MAX_UNITS_SIZE], short &noStr, char strs [MAX_ENUM_STATES][MAX_ENUM_STRING_SIZE],
01787 bool isCacheRequest) {
01788 #define __METHOD__ "Transpose<CTYPE>::getCtrl()"
01789
01790 cafeConduit_set_by_handle & handle_index=cs.get<by_handle>();
01791 cafeConduit_set_by_handle::iterator it_handle;
01792 it_handle = handle_index.find(_handle);
01793
01794
01795 if (it_handle != handle_index.end()) {
01796
01797 PVDataL = (*it_handle).getCtrlBuffer ();
01798
01799 offset = (*it_handle).getChannelRequestMetaCtrlClient().getOffset();
01800 if(isCacheRequest) {
01801 nelem = (*it_handle).getChannelRequestMetaCtrl().getNelemCache() - (*it_handle).getChannelRequestMetaCtrl().getOffset();
01802 }
01803 else {
01804 nelem = (*it_handle).getChannelRequestMetaCtrl().getNelem()-offset;
01805 }
01806
01807 if (nelem <=0) {
01808 cout << __FILE__ << "//" << __LINE__ << "//" << __METHOD__ << endl;
01809 cout << "Something funny with the offset; just read last element! " << endl;
01810 cout << "Changing offset from=" << offset;
01811
01812 offset = (*it_handle).getChannelRequestMetaCtrl().getNelem()-1;
01813 if(isCacheRequest) {
01814 nelem = (*it_handle).getChannelRequestMetaCtrl().getNelemCache() - (*it_handle).getChannelRequestMetaCtrl().getOffset();
01815 }
01816 else {
01817 nelem = (*it_handle).getChannelRequestMetaCtrl().getNelem()-offset;
01818 }
01819 cout << " to=" << offset << endl;
01820 }
01821
01822
01823 dbrTypeRequest_CtrlBuffer = (*it_handle).getChannelRequestMetaCtrl().getDbrDataType();
01824 _dataTypeClient = (*it_handle).getChannelRequestMetaDataClient().getDataType();
01825
01826
01827 alarmStatus = -1;
01828 alarmSeverity = -1;
01829
01830 if (_dataTypeClient < DBR_STRING || _dataTypeClient > DBR_DOUBLE) {
01831 cout << __FILE__ << "/" << __LINE__ << "/" << __METHOD__ << endl;
01832 cout << "Datatype requested " << dbr_type_to_text(_dataTypeClient)
01833 << " is not within allowed range: " << endl;
01834 cout << "DBR_STRING <= dataType <= DBR_DOUBLE" << endl;
01835 cout << "CAFE ERROR: ECAFE_INVALID_SWITCH_CASE" << endl;
01836 return ECAFE_INVALID_SWITCH_CASE;
01837 }
01838
01839
01840 noStr=0;
01841
01842
01843
01844
01845
01846
01847 switch (dbrTypeRequest_CtrlBuffer) {
01848
01849 case DBR_CTRL_CHAR:
01850
01851 switch(_dataTypeClient){
01852 case DBR_CHAR:
01853 memcpy(val, &(&((PVDataL)->cchrval.value))[offset], sizeof(dbr_char_t)*nelem);
01854 break;
01855 case DBR_DOUBLE:
01856 case DBR_SHORT:
01857 case DBR_ENUM:
01858 case DBR_LONG:
01859 case DBR_FLOAT:
01860 for (unsigned int i=0; i<nelem; ++i) {
01861 val[i] = (CTYPE) (*(&((PVDataL)->cchrval.value)+i+offset));
01862 }
01863 break;
01864
01865 case DBR_STRING:
01866 default:
01867 break;
01868 }
01869
01870 precision = 0;
01871 RISC_pad = ((struct dbr_ctrl_char *) PVDataL)->RISC_pad;
01872 alarmStatus = ((struct dbr_ctrl_char *) PVDataL)->status;
01873 alarmSeverity = ((struct dbr_ctrl_char *) PVDataL)->severity;
01874
01875 memcpy(units, &(((struct dbr_ctrl_char *) PVDataL)->units), sizeof(char[MAX_UNITS_SIZE]));
01876
01877 upperDispLimit = (CTYPE) ((struct dbr_ctrl_char *) PVDataL)->upper_disp_limit;
01878 lowerDispLimit = (CTYPE) ((struct dbr_ctrl_char *) PVDataL)->lower_disp_limit;
01879 upperAlarmLimit = (CTYPE) ((struct dbr_ctrl_char *) PVDataL)->upper_alarm_limit;
01880 upperWarningLimit = (CTYPE) ((struct dbr_ctrl_char *) PVDataL)->upper_warning_limit;
01881 lowerWarningLimit = (CTYPE) ((struct dbr_ctrl_char *) PVDataL)->lower_warning_limit;
01882 lowerAlarmLimit = (CTYPE) ((struct dbr_ctrl_char *) PVDataL)->lower_alarm_limit;
01883 upperCtrlLimit = (CTYPE) ((struct dbr_ctrl_char *) PVDataL)->upper_ctrl_limit;
01884 lowerCtrlLimit = (CTYPE) ((struct dbr_ctrl_char *) PVDataL)->lower_ctrl_limit;
01885
01886 break;
01887
01888 case DBR_CTRL_ENUM:
01889 switch(_dataTypeClient){
01890 case DBR_ENUM:
01891 memcpy(val, &(&((PVDataL)->cenmval.value))[offset], sizeof(dbr_enum_t)*nelem);
01892
01893 break;
01894 case DBR_DOUBLE:
01895 case DBR_SHORT:
01896 case DBR_CHAR:
01897 case DBR_LONG:
01898 case DBR_FLOAT:
01899 for (unsigned int i=0; i<nelem; ++i) {
01900 val[i] = (CTYPE) (*(&((PVDataL)->cenmval.value)+i));
01901 }
01902 break;
01903
01904 case DBR_STRING:
01905 default:
01906 break;
01907 }
01908
01909 precision = 0;
01910 RISC_pad = 0;
01911 alarmStatus = ((struct dbr_ctrl_enum *) PVDataL)->status;
01912 alarmSeverity = ((struct dbr_ctrl_enum *) PVDataL)->severity;
01913 noStr = ((struct dbr_ctrl_enum *) PVDataL)->no_str;
01914
01915 memcpy(strs , &(((struct dbr_ctrl_enum *) PVDataL)->strs),
01916 sizeof(char)*MAX_ENUM_STRING_SIZE*MAX_ENUM_STATES);
01917
01918
01919
01920
01921 memcpy(units,"",sizeof(char[MAX_UNITS_SIZE]));
01922
01923 upperDispLimit = (CTYPE) 0;
01924 lowerDispLimit = (CTYPE) 0;
01925 upperAlarmLimit = (CTYPE) 0;
01926 upperWarningLimit = (CTYPE) 0;
01927 lowerWarningLimit = (CTYPE) 0;
01928 lowerAlarmLimit = (CTYPE) 0;
01929 upperCtrlLimit = (CTYPE) 0;
01930 lowerCtrlLimit = (CTYPE) 0;
01931
01932 break;
01933
01934 case DBR_CTRL_FLOAT:
01935 switch(_dataTypeClient){
01936 case DBR_FLOAT:
01937 memcpy(val, &(&((PVDataL)->cfltval.value))[offset], sizeof(dbr_float_t)*nelem);
01938
01939 break;
01940 case DBR_SHORT:
01941 case DBR_LONG:
01942 case DBR_ENUM:
01943 case DBR_CHAR:
01944 case DBR_DOUBLE:
01945 for (unsigned int i=0; i<nelem; ++i) {
01946 val[i] = (CTYPE) (*(&((PVDataL)->cfltval.value)+i+offset)) ;
01947 }
01948 break;
01949
01950 case DBR_STRING:
01951 default:
01952 break;
01953 }
01954
01955 precision = ((struct dbr_ctrl_float *) PVDataL)->precision;
01956 RISC_pad = ((struct dbr_ctrl_float *) PVDataL)->RISC_pad;
01957
01958
01959
01960
01961 alarmStatus = ((struct dbr_ctrl_float *) PVDataL)->status;
01962 alarmSeverity = ((struct dbr_ctrl_float *) PVDataL)->severity;
01963
01964 memcpy(units, &(((struct dbr_ctrl_float *) PVDataL)->units), sizeof(char[MAX_UNITS_SIZE]));
01965
01966 upperDispLimit = (CTYPE) ((struct dbr_ctrl_float *) PVDataL)->upper_disp_limit;
01967 lowerDispLimit = (CTYPE) ((struct dbr_ctrl_float *) PVDataL)->lower_disp_limit;
01968 upperAlarmLimit = (CTYPE) ((struct dbr_ctrl_float *) PVDataL)->upper_alarm_limit;
01969 upperWarningLimit = (CTYPE) ((struct dbr_ctrl_float *) PVDataL)->upper_warning_limit;
01970 lowerWarningLimit = (CTYPE) ((struct dbr_ctrl_float *) PVDataL)->lower_warning_limit;
01971 lowerAlarmLimit = (CTYPE) ((struct dbr_ctrl_float *) PVDataL)->lower_alarm_limit;
01972 upperCtrlLimit = (CTYPE) ((struct dbr_ctrl_float *) PVDataL)->upper_ctrl_limit;
01973 lowerCtrlLimit = (CTYPE) ((struct dbr_ctrl_float *) PVDataL)->lower_ctrl_limit;
01974
01975
01976
01977
01978 break;
01979
01980 case DBR_CTRL_DOUBLE:
01981 switch(_dataTypeClient){
01982 case DBR_DOUBLE:
01983 memcpy(val, &(&((PVDataL)->cdblval.value))[offset], sizeof(dbr_double_t)*nelem);
01984
01985 break;
01986 case DBR_SHORT:
01987 case DBR_LONG:
01988 case DBR_ENUM:
01989 case DBR_CHAR:
01990 case DBR_FLOAT:
01991 for (unsigned int i=0; i<nelem; ++i) {
01992 val[i] = (CTYPE) (*(&((PVDataL)->cdblval.value)+i+offset));
01993 }
01994 break;
01995
01996 case DBR_STRING:
01997 default:
01998 break;
01999 }
02000
02001 precision = ((struct dbr_ctrl_double *) PVDataL)->precision;
02002 RISC_pad = (short) ((struct dbr_ctrl_double *) PVDataL)->RISC_pad0;
02003 alarmStatus = ((struct dbr_ctrl_double *) PVDataL)->status;
02004 alarmSeverity = ((struct dbr_ctrl_double *) PVDataL)->severity;
02005
02006 memcpy(units, &(((struct dbr_ctrl_double *) PVDataL)->units), sizeof(char[MAX_UNITS_SIZE]));
02007
02008 upperDispLimit = (CTYPE) ((struct dbr_ctrl_double *) PVDataL)->upper_disp_limit;
02009 lowerDispLimit = (CTYPE) ((struct dbr_ctrl_double *) PVDataL)->lower_disp_limit;
02010 upperAlarmLimit = (CTYPE) ((struct dbr_ctrl_double *) PVDataL)->upper_alarm_limit;
02011 upperWarningLimit = (CTYPE) ((struct dbr_ctrl_double *) PVDataL)->upper_warning_limit;
02012 lowerWarningLimit = (CTYPE) ((struct dbr_ctrl_double *) PVDataL)->lower_warning_limit;
02013 lowerAlarmLimit = (CTYPE) ((struct dbr_ctrl_double *) PVDataL)->lower_alarm_limit;
02014 upperCtrlLimit = (CTYPE) ((struct dbr_ctrl_double *) PVDataL)->upper_ctrl_limit;
02015 lowerCtrlLimit = (CTYPE) ((struct dbr_ctrl_double *) PVDataL)->lower_ctrl_limit;
02016
02017 break;
02018
02019 case DBR_CTRL_SHORT:
02020 switch(_dataTypeClient){
02021 case DBR_SHORT:
02022 memcpy(val, &(&((PVDataL)->cshrtval.value))[offset], sizeof(dbr_short_t)*nelem);
02023
02024 break;
02025 case DBR_DOUBLE:
02026 case DBR_LONG:
02027 case DBR_ENUM:
02028 case DBR_CHAR:
02029 case DBR_FLOAT:
02030 for (unsigned int i=0; i<nelem; ++i) {
02031 val[i] = (CTYPE) (*(&((PVDataL)->cshrtval.value)+i+offset));
02032 }
02033 break;
02034
02035 case DBR_STRING:
02036 default:
02037 break;
02038 }
02039
02040
02041 precision = 0;
02042 RISC_pad = 0;
02043 alarmStatus = ((struct dbr_ctrl_short *) PVDataL)->status;
02044 alarmSeverity = ((struct dbr_ctrl_short *) PVDataL)->severity;
02045
02046 memcpy(units, &(((struct dbr_ctrl_short *) PVDataL)->units), sizeof(char[MAX_UNITS_SIZE]));
02047
02048 upperDispLimit = (CTYPE) ((struct dbr_ctrl_short *) PVDataL)->upper_disp_limit;
02049 lowerDispLimit = (CTYPE) ((struct dbr_ctrl_short *) PVDataL)->lower_disp_limit;
02050 upperAlarmLimit = (CTYPE) ((struct dbr_ctrl_short *) PVDataL)->upper_alarm_limit;
02051 upperWarningLimit = (CTYPE) ((struct dbr_ctrl_short *) PVDataL)->upper_warning_limit;
02052 lowerWarningLimit = (CTYPE) ((struct dbr_ctrl_short *) PVDataL)->lower_warning_limit;
02053 lowerAlarmLimit = (CTYPE) ((struct dbr_ctrl_short *) PVDataL)->lower_alarm_limit;
02054 upperCtrlLimit = (CTYPE) ((struct dbr_ctrl_short *) PVDataL)->upper_ctrl_limit;
02055 lowerCtrlLimit = (CTYPE) ((struct dbr_ctrl_short *) PVDataL)->lower_ctrl_limit;
02056
02057 break;
02058
02059
02060 case DBR_CTRL_LONG:
02061 switch(_dataTypeClient){
02062 case DBR_LONG:
02063 memcpy(val, &(&((PVDataL)->clngval.value))[offset], sizeof(dbr_long_t)*nelem);
02064 break;
02065 case DBR_DOUBLE:
02066 case DBR_SHORT:
02067 case DBR_ENUM:
02068 case DBR_CHAR:
02069 case DBR_FLOAT:
02070 for (unsigned int i=0; i<nelem; ++i) {
02071 val[i] = (CTYPE) (*(&((PVDataL)->clngval.value)+i+offset));
02072 }
02073 break;
02074
02075 case DBR_STRING:
02076 default:
02077 break;
02078 }
02079
02080 precision = 0;
02081 RISC_pad = 0;
02082
02083 alarmStatus = ((struct dbr_ctrl_long *) PVDataL)->status;
02084 alarmSeverity = ((struct dbr_ctrl_long *) PVDataL)->severity;
02085
02086 memcpy(units, &(((struct dbr_ctrl_long *) PVDataL)->units),sizeof(char[MAX_UNITS_SIZE])) ;
02087
02088 upperDispLimit = (CTYPE) ((struct dbr_ctrl_long *) PVDataL)->upper_disp_limit;
02089 lowerDispLimit = (CTYPE) ((struct dbr_ctrl_long *) PVDataL)->lower_disp_limit;
02090 upperAlarmLimit = (CTYPE) ((struct dbr_ctrl_long *) PVDataL)->upper_alarm_limit;
02091 upperWarningLimit = (CTYPE) ((struct dbr_ctrl_long *) PVDataL)->upper_warning_limit;
02092 lowerWarningLimit = (CTYPE) ((struct dbr_ctrl_long *) PVDataL)->lower_warning_limit;
02093 lowerAlarmLimit = (CTYPE) ((struct dbr_ctrl_long *) PVDataL)->lower_alarm_limit;
02094 upperCtrlLimit = (CTYPE) ((struct dbr_ctrl_long *) PVDataL)->upper_ctrl_limit;
02095 lowerCtrlLimit = (CTYPE) ((struct dbr_ctrl_long *) PVDataL)->lower_ctrl_limit;
02096
02097 break;
02098 }
02099
02100 }
02101 else {
02102 cafeStatus.report(ECAFE_INVALID_HANDLE);
02103 return ECAFE_INVALID_HANDLE;
02104 }
02105
02106 return ICAFE_NORMAL;
02107 #undef __METHOD__
02108 }
02109
02110
02111 #endif // TRANSPOSE_H
02112
02113
02114
02115
02116
02117
