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