conduitEventHandlerArgs.h
Go to the documentation of this file.00001
00002
00003
00004
00005
00006
00007
00008 #ifndef CONDUITEVENTHANDLERARGS_H
00009 #define CONDUITEVENTHANDLERARGS_H
00010
00011 #include <cadef.h>
00012 #include <conduit.h>
00013 #include <helper.h>
00014
00015
00020 struct change_eventHandlerArgs
00021 {
00022 #define __METHOD__ "change_eventHandlerArgs"
00023 change_eventHandlerArgs (const struct event_handler_args & new_eventHandlerArgs) :
00024 new_eventHandlerArgs(new_eventHandlerArgs){}
00025
00026 void operator() (Conduit& c) {
00027
00028
00029
00030 c.status= new_eventHandlerArgs.status;
00031 if(c.status!=ECA_NORMAL) return;
00032
00033 Helper helper;
00034
00035 chtype requestedT= new_eventHandlerArgs.type%DBR_STS_STRING;
00036 chtype bufferType= new_eventHandlerArgs.type;
00037
00038
00039 CAFENUM::DBR_TYPE dbrTypeClass=helper.convertToCAFEDbrTypeClass(new_eventHandlerArgs.type);
00040
00041
00042
00043 c.usrArgs = new_eventHandlerArgs.usr;
00044 c.dataType= requestedT;
00045 c.dbrDataType= bufferType;
00046 c.cafeDbrType= dbrTypeClass;
00047
00048 c.hasNewData=true;
00049
00050
00051 if (new_eventHandlerArgs.type < DBR_GR_STRING) {
00052 bufferType = dbf_type_to_DBR_TIME(requestedT);
00053 }
00054 else if (new_eventHandlerArgs.type < DBR_PUT_ACKT) {
00055 bufferType = dbf_type_to_DBR_CTRL(requestedT);
00056 }
00057 else if (new_eventHandlerArgs.type < (LAST_BUFFER_TYPE+1)) {
00058
00059 }
00060 else {
00061 cout << __FILE__ << "/" << __LINE__ << "/" << __METHOD__ << endl;
00062 cout << "CAFE INTERNAL FUNNY: UNKNOWN event_handler_args.type= "
00063 << new_eventHandlerArgs.type << endl;
00064 }
00065
00066
00067
00068 unsigned int nrequired = dbr_size_n(bufferType, new_eventHandlerArgs.count);
00069 unsigned int navailable = nrequired;
00070
00071
00072
00073
00074
00075 switch(dbrTypeClass)
00076 {
00077 case CAFENUM::DBR_STSACK:
00078 navailable = c.channelRequestMetaSTSACK.byteSize;
00079 c.channelRequestMetaSTSACK.nelem = new_eventHandlerArgs.count;
00080 c.channelRequestMetaSTSACK.dataType = requestedT;
00081 c.channelRequestMetaSTSACK.dbrDataType = new_eventHandlerArgs.type;
00082 c.channelRequestMetaSTSACK.cafeDbrType = dbrTypeClass;
00083 c.channelRequestMetaSTSACK.usrArg = new_eventHandlerArgs.usr;
00084 break;
00085 case CAFENUM::DBR_PRIMITIVE:
00086 case CAFENUM::DBR_STS:
00087 case CAFENUM::DBR_TIME:
00088 navailable = c.channelRequestMetaData.byteSize;
00089 c.channelRequestMetaData.nelem = new_eventHandlerArgs.count;
00090 c.channelRequestMetaData.dataType = requestedT;
00091 c.channelRequestMetaData.dbrDataType = new_eventHandlerArgs.type;
00092 c.channelRequestMetaData.cafeDbrType = dbrTypeClass;
00093 c.channelRequestMetaData.usrArg = new_eventHandlerArgs.usr;
00094 if (nrequired > navailable) {
00095 c.channelRequestMetaData.byteSize = nrequired;
00096 }
00097 break;
00098 case CAFENUM::DBR_GR:
00099 case CAFENUM::DBR_CTRL:
00100 navailable = c.channelRequestMetaCtrl.byteSize;
00101 c.channelRequestMetaCtrl.nelem = new_eventHandlerArgs.count;
00102 c.channelRequestMetaCtrl.dataType = requestedT;
00103 c.channelRequestMetaCtrl.dbrDataType = new_eventHandlerArgs.type;
00104 c.channelRequestMetaCtrl.cafeDbrType = dbrTypeClass;
00105 c.channelRequestMetaCtrl.usrArg = new_eventHandlerArgs.usr;
00106 if (nrequired > navailable) {
00107 c.channelRequestMetaCtrl.byteSize = nrequired;
00108 }
00109 break;
00110 case CAFENUM::DBR_CLASS:
00111 break;
00112 case CAFENUM::DBR_NONE:
00113 break;
00114 default:
00115 cout << __FILE__ << "/" << __LINE__ << "/" << __METHOD__ << endl;
00116 cout << "CAFE INTERNAL FUNNY: UNKNOWN CAFENUM::DBR_TYPE= " << dbrTypeClass << endl;
00117 break;
00118 }
00119
00120 if (nrequired > navailable) {
00121
00122 cout << __FILE__ << "/" << __LINE__ << "/" << __METHOD__ << endl;
00123 cout << "CHANGE OF BUFFER SIZE: FROM " << navailable << " bytes TO " << nrequired << " bytes" << endl;
00124 cout << "Channel-" << c.pv << " ca-name=" << ca_name(new_eventHandlerArgs.chid)
00125 << " type=" << new_eventHandlerArgs.type
00126 << " type=" << dbr_type_to_text(new_eventHandlerArgs.type) << endl;
00127
00128
00129 switch(dbrTypeClass)
00130 {
00131 case CAFENUM::DBR_STSACK:
00132
00133 if (c.stsackBuffer!=NULL) {
00134 free(c.stsackBuffer);
00135 }
00136 else {
00137 cout << __FILE__ << "/" << __LINE__ << "/" << __METHOD__ << endl;
00138 cout << "CAFE INTERNAL FUNNY: HOW CAN stsackBuffer NOT ALREADY EXIST?" << endl;
00139 cout << "CREATING stsackBuffer " << endl;
00140 }
00141
00142 c.stsackBuffer = (db_access_val *) malloc (nrequired);
00143
00144
00145 if (c.stsackBuffer==NULL){
00146 cout << __FILE__ << "/" << __LINE__ << "/" << __METHOD__ << endl;
00147 printf ("Virtual memory exhausted for channel %s ", ca_name(c.channelID));
00148 printf ("Exiting CAFE");
00149 exit(0);
00150 }
00151
00152 c.channelRequestMetaSTSACK.byteSize=nrequired;
00153
00154
00155
00156 break;
00157
00158 case CAFENUM::DBR_PRIMITIVE:
00159 case CAFENUM::DBR_STS:
00160 case CAFENUM::DBR_TIME:
00161
00162
00163 if (c.dataBuffer != NULL){
00164
00165
00166
00167
00168
00169 free(c.dataBuffer);
00170 }
00171 else {
00172 cout << __FILE__ << "/" << __LINE__ << "/" << __METHOD__ << endl;
00173 cout << "CAFE INTERNAL FUNNY: HOW CAN dataBuffer NOT ALREADY EXIST?" << endl;
00174 cout << "CREATING dataBuffer " << endl;
00175 }
00176
00177 c.dataBuffer = (db_access_val *) malloc (nrequired);
00178
00179 if (c.dataBuffer==NULL){
00180 cout << __FILE__ << "/" << __LINE__ << "/" << __METHOD__ << endl;
00181 printf ("Virtual memory exhausted for channel %s ", ca_name(c.channelID));
00182 printf ("Exiting CAFE");
00183 exit(0);
00184 }
00185 c.channelRequestMetaData.byteSize=nrequired;
00186
00187
00188 break;
00189
00190 case CAFENUM::DBR_CTRL:
00191
00192
00193 if (c.ctrlBuffer != NULL){
00194
00195
00196
00197
00198
00199 free(c.ctrlBuffer);
00200 }
00201 else {
00202 cout << __FILE__ << "/" << __LINE__ << "/" << __METHOD__ << endl;
00203 cout << "CAFE INTERNAL FUNNY: HOW CAN dataBuffer NOT ALREADY EXIST?" << endl;
00204 cout << "CREATING dataBuffer " << endl;
00205 }
00206
00207 c.ctrlBuffer = (db_access_val *) malloc (nrequired);
00208
00209 if (c.ctrlBuffer==NULL){
00210 cout << __FILE__ << "/" << __LINE__ << "/" << __METHOD__ << endl;
00211 printf ("Virtual memory exhausted for channel %s ", ca_name(c.channelID));
00212 printf ("Exiting CAFE");
00213 exit(0);
00214 }
00215
00216 c.channelRequestMetaCtrl.byteSize=nrequired;
00217
00218
00219
00220
00221
00222 break;
00223
00224 case CAFENUM::DBR_CLASS:
00225 default:
00226 break;
00227 }
00228 }
00229
00230
00231 if (new_eventHandlerArgs.count > 0) {
00232 if ((unsigned int) new_eventHandlerArgs.count > c.channelRegalia.nelem) {
00233 c.channelRegalia.nelem = (unsigned int) new_eventHandlerArgs.count;
00234 }
00235 }
00236
00237 switch(dbrTypeClass)
00238 {
00239 case CAFENUM::DBR_PRIMITIVE:
00240
00241
00242
00243
00244 c.alarmStatus =-1;
00245 c.alarmSeverity =-1;
00246 c.ts.secPastEpoch =0;
00247 c.ts.nsec =0;
00248 break;
00249 case CAFENUM::DBR_STS:
00250
00251
00252
00253
00254 c.ts.secPastEpoch =0;
00255 c.ts.nsec =0;
00256 break;
00257 case CAFENUM::DBR_TIME:
00258
00259
00260
00261
00262 break;
00263 case CAFENUM::DBR_CTRL:
00264
00265
00266
00267
00268 break;
00269 case CAFENUM::DBR_STSACK:
00270
00271
00272
00273
00274 break;
00275 case CAFENUM::DBR_CLASS:
00276
00277
00278
00279
00280 break;
00281 case CAFENUM::DBR_PUT:
00282 break;
00283 case CAFENUM::DBR_NONE:
00284 default:
00285
00286
00287
00288
00289 cout << __FILE__ << "/" << __LINE__ << "/" << __METHOD__ << endl;
00290 cout << "CAFE INTERNAL ERROR. Datatype not catered for: "
00291 << dbf_type_to_text(new_eventHandlerArgs.type) << endl;
00292 cout << new_eventHandlerArgs.type << endl;
00293 break;
00294 }
00295
00296
00297
00298 switch(new_eventHandlerArgs.type)
00299 {
00300 case DBR_DOUBLE:
00301
00302 for (long i=0; i<new_eventHandlerArgs.count; ++i) {
00303 (*(&((c.dataBuffer)->doubleval)+i))
00304 = (*(&( ((union db_access_val *) new_eventHandlerArgs.dbr)->doubleval)+i));
00305 }
00306
00307 break;
00308
00309 case DBR_FLOAT:
00310
00311 for (long i=0; i<new_eventHandlerArgs.count; ++i) {
00312 (*(&((c.dataBuffer)->fltval)+i))
00313 = (dbr_float_t) (*(&( ( (union db_access_val *) new_eventHandlerArgs.dbr)->fltval)+i));
00314 }
00315
00316
00317 break;
00318
00319 case DBR_LONG:
00320
00321 for (long i=0; i<new_eventHandlerArgs.count; ++i) {
00322 (*(&((c.dataBuffer)->longval)+i))
00323 = (*(&(( (union db_access_val *) new_eventHandlerArgs.dbr)->longval)+i));
00324 }
00325 break;
00326
00327 case DBR_SHORT:
00328
00329 for (long i=0; i<new_eventHandlerArgs.count; ++i) {
00330 (*(&((c.dataBuffer)->shrtval)+i))
00331 = (*(&(((union db_access_val *) new_eventHandlerArgs.dbr)->shrtval)+i));
00332 }
00333 break;
00334
00335 case DBR_STRING:
00336
00337 for (long i=0; i<new_eventHandlerArgs.count; ++i) {
00338 strcpy ((*(&((c.dataBuffer)->strval)+i)) ,
00339 (*(&(((union db_access_val *) new_eventHandlerArgs.dbr)->strval)+i)) );
00340 }
00341 break;
00342
00343 case DBR_ENUM:
00344
00345 for (long i=0; i<new_eventHandlerArgs.count; ++i) {
00346 (*(&((c.dataBuffer)->enmval)+i))
00347 = (*(&(((union db_access_val *) new_eventHandlerArgs.dbr)->enmval)+i));
00348 }
00349 break;
00350
00351 case DBR_CHAR:
00352
00353 for (long i=0; i<new_eventHandlerArgs.count; ++i) {
00354 (*(&((c.dataBuffer)->charval)+i))
00355 = (*(&(((union db_access_val *) new_eventHandlerArgs.dbr)->charval)+i));
00356 }
00357 break;
00358
00359
00360 case DBR_STS_DOUBLE:
00361
00362 for (long i=0; i<new_eventHandlerArgs.count; ++i) {
00363 (*(&((c.dataBuffer)->sdblval.value)+i))
00364 = (*(&( ((union db_access_val *) new_eventHandlerArgs.dbr)->sdblval.value)+i));
00365 }
00366 (*(&((c.dataBuffer)->sdblval.status))) = ((struct dbr_sts_double *) new_eventHandlerArgs.dbr)->status;
00367 (*(&((c.dataBuffer)->sdblval.severity))) = ((struct dbr_sts_double *) new_eventHandlerArgs.dbr)->severity;
00368
00369 c.alarmStatus =((struct dbr_sts_double *) new_eventHandlerArgs.dbr)->status;
00370 c.alarmSeverity=((struct dbr_sts_double *) new_eventHandlerArgs.dbr)->severity;
00371
00372 break;
00373
00374 case DBR_STS_FLOAT:
00375
00376 for (long i=0; i<new_eventHandlerArgs.count; ++i) {
00377 (*(&((c.dataBuffer)->sfltval.value)+i))
00378 = (dbr_float_t) (*(&( ( (union db_access_val *) new_eventHandlerArgs.dbr)->sfltval.value)+i));
00379 }
00380
00381 (*(&((c.dataBuffer)->sfltval.status))) = ((struct dbr_sts_float *) new_eventHandlerArgs.dbr)->status;
00382 (*(&((c.dataBuffer)->sfltval.severity))) = ((struct dbr_sts_float *) new_eventHandlerArgs.dbr)->severity;
00383
00384 c.alarmStatus =((struct dbr_sts_float *) new_eventHandlerArgs.dbr)->status;
00385 c.alarmSeverity=((struct dbr_sts_float *) new_eventHandlerArgs.dbr)->severity;
00386
00387 break;
00388
00389 case DBR_STS_LONG:
00390
00391 for (long i=0; i<new_eventHandlerArgs.count; ++i) {
00392 (*(&((c.dataBuffer)->slngval.value)+i))
00393 = (*(&(( (union db_access_val *) new_eventHandlerArgs.dbr)->slngval.value)+i));
00394 }
00395
00396 (*(&((c.dataBuffer)->slngval.status))) = ((struct dbr_sts_long *) new_eventHandlerArgs.dbr)->status;
00397 (*(&((c.dataBuffer)->slngval.severity))) = ((struct dbr_sts_long *) new_eventHandlerArgs.dbr)->severity;
00398
00399 c.alarmStatus =((struct dbr_sts_long *) new_eventHandlerArgs.dbr)->status;
00400 c.alarmSeverity=((struct dbr_sts_long *) new_eventHandlerArgs.dbr)->severity;
00401
00402 break;
00403
00404 case DBR_STS_SHORT:
00405
00406 for (long i=0; i<new_eventHandlerArgs.count; ++i) {
00407 (*(&((c.dataBuffer)->sshrtval.value)+i))
00408 = (*(&(((union db_access_val *) new_eventHandlerArgs.dbr)->sshrtval.value)+i));
00409 }
00410 (*(&((c.dataBuffer)->sshrtval.status))) = ((struct dbr_sts_short *) new_eventHandlerArgs.dbr)->status;
00411 (*(&((c.dataBuffer)->sshrtval.severity))) = ((struct dbr_sts_short *) new_eventHandlerArgs.dbr)->severity;
00412
00413 c.alarmStatus =((struct dbr_sts_short *) new_eventHandlerArgs.dbr)->status;
00414 c.alarmSeverity=((struct dbr_sts_short *) new_eventHandlerArgs.dbr)->severity;
00415 break;
00416
00417 case DBR_STS_STRING:
00418
00419 for (long i=0; i<new_eventHandlerArgs.count; ++i) {
00420 strcpy ((*(&((c.dataBuffer)->sstrval.value)+i)) ,
00421 (*(&(((union db_access_val *) new_eventHandlerArgs.dbr)->sstrval.value)+i)) );
00422 }
00423 (*(&((c.dataBuffer)->sstrval.status))) = ((struct dbr_sts_string *) new_eventHandlerArgs.dbr)->status;
00424 (*(&((c.dataBuffer)->sstrval.severity))) = ((struct dbr_sts_string *) new_eventHandlerArgs.dbr)->severity;
00425
00426 c.alarmStatus =((struct dbr_sts_string *) new_eventHandlerArgs.dbr)->status;
00427 c.alarmSeverity=((struct dbr_sts_string *) new_eventHandlerArgs.dbr)->severity;
00428
00429 break;
00430
00431 case DBR_STS_ENUM:
00432
00433 for (long i=0; i<new_eventHandlerArgs.count; ++i) {
00434 (*(&((c.dataBuffer)->senmval.value)+i))
00435 = (*(&(((union db_access_val *) new_eventHandlerArgs.dbr)->senmval.value)+i));
00436 }
00437 (*(&((c.dataBuffer)->senmval.status))) = ((struct dbr_sts_enum *) new_eventHandlerArgs.dbr)->status;
00438 (*(&((c.dataBuffer)->senmval.severity))) = ((struct dbr_sts_enum *) new_eventHandlerArgs.dbr)->severity;
00439
00440 c.alarmStatus =((struct dbr_sts_enum *) new_eventHandlerArgs.dbr)->status;
00441 c.alarmSeverity=((struct dbr_sts_enum *) new_eventHandlerArgs.dbr)->severity;
00442
00443 break;
00444
00445 case DBR_STS_CHAR:
00446
00447 for (long i=0; i<new_eventHandlerArgs.count; ++i) {
00448 (*(&((c.dataBuffer)->schrval.value)+i))
00449 = (*(&(((union db_access_val *) new_eventHandlerArgs.dbr)->schrval.value)+i));
00450 }
00451
00452 (*(&((c.dataBuffer)->schrval.status))) = ((struct dbr_sts_char *) new_eventHandlerArgs.dbr)->status;
00453 (*(&((c.dataBuffer)->schrval.severity))) = ((struct dbr_sts_char *) new_eventHandlerArgs.dbr)->severity;
00454
00455 c.alarmStatus =((struct dbr_sts_char *) new_eventHandlerArgs.dbr)->status;
00456 c.alarmSeverity=((struct dbr_sts_char *) new_eventHandlerArgs.dbr)->severity;
00457
00458 break;
00459
00460 case DBR_TIME_DOUBLE:
00461
00462 for (long i=0; i<new_eventHandlerArgs.count; ++i) {
00463 (*(&((c.dataBuffer)->tdblval.value)+i))
00464 = (*(&( ((union db_access_val *) new_eventHandlerArgs.dbr)->tdblval.value)+i));
00465 }
00466
00467 (*(&((c.dataBuffer)->tdblval.status))) = ((struct dbr_time_double *) new_eventHandlerArgs.dbr)->status;
00468 (*(&((c.dataBuffer)->tdblval.severity))) = ((struct dbr_time_double *) new_eventHandlerArgs.dbr)->severity;
00469 (*(&((c.dataBuffer)->tdblval.stamp))) = ((struct dbr_time_double *) new_eventHandlerArgs.dbr)->stamp;
00470
00471 c.alarmStatus =((struct dbr_time_double *) new_eventHandlerArgs.dbr)->status;
00472 c.alarmSeverity=((struct dbr_time_double *) new_eventHandlerArgs.dbr)->severity;
00473 c.ts =((struct dbr_time_double *) new_eventHandlerArgs.dbr)->stamp;
00474
00475 break;
00476
00477 case DBR_TIME_FLOAT:
00478
00479 for (long i=0; i<new_eventHandlerArgs.count; ++i) {
00480
00481 (*(&((c.dataBuffer)->tfltval.value)+i))
00482 = (dbr_float_t) (*(&( ( (union db_access_val *) new_eventHandlerArgs.dbr)->tfltval.value)+i));
00483
00484
00485 }
00486
00487 (*(&((c.dataBuffer)->tfltval.status))) = ((struct dbr_time_float *) new_eventHandlerArgs.dbr)->status;
00488 (*(&((c.dataBuffer)->tfltval.severity))) = ((struct dbr_time_float *) new_eventHandlerArgs.dbr)->severity;
00489 (*(&((c.dataBuffer)->tfltval.stamp))) = ((struct dbr_time_float *) new_eventHandlerArgs.dbr)->stamp;
00490
00491 c.alarmStatus =((struct dbr_time_float *) new_eventHandlerArgs.dbr)->status;
00492 c.alarmSeverity=((struct dbr_time_float *) new_eventHandlerArgs.dbr)->severity;
00493 c.ts =((struct dbr_time_float *) new_eventHandlerArgs.dbr)->stamp;
00494
00495 break;
00496
00497 case DBR_TIME_LONG:
00498
00499 for (long i=0; i<new_eventHandlerArgs.count; ++i) {
00500 (*(&((c.dataBuffer)->tlngval.value)+i))
00501 = (*(&(( (union db_access_val *) new_eventHandlerArgs.dbr)->tlngval.value)+i));
00502 }
00503
00504 (*(&((c.dataBuffer)->tlngval.status))) = ((struct dbr_time_long *) new_eventHandlerArgs.dbr)->status;
00505 (*(&((c.dataBuffer)->tlngval.severity))) = ((struct dbr_time_long *) new_eventHandlerArgs.dbr)->severity;
00506 (*(&((c.dataBuffer)->tlngval.stamp))) = ((struct dbr_time_long *) new_eventHandlerArgs.dbr)->stamp;
00507
00508 c.alarmStatus =((struct dbr_time_long *) new_eventHandlerArgs.dbr)->status;
00509 c.alarmSeverity=((struct dbr_time_long *) new_eventHandlerArgs.dbr)->severity;
00510 c.ts =((struct dbr_time_long *) new_eventHandlerArgs.dbr)->stamp;
00511 break;
00512
00513 case DBR_TIME_SHORT:
00514 for (long i=0; i<new_eventHandlerArgs.count; ++i) {
00515 (*(&((c.dataBuffer)->tshrtval.value)+i))
00516 = (*(&(((union db_access_val *) new_eventHandlerArgs.dbr)->tshrtval.value)+i));
00517 }
00518
00519 (*(&((c.dataBuffer)->tshrtval.status))) = ((struct dbr_time_short *) new_eventHandlerArgs.dbr)->status;
00520 (*(&((c.dataBuffer)->tshrtval.severity))) = ((struct dbr_time_short *) new_eventHandlerArgs.dbr)->severity;
00521 (*(&((c.dataBuffer)->tshrtval.stamp))) = ((struct dbr_time_short *) new_eventHandlerArgs.dbr)->stamp;
00522
00523 c.alarmStatus =((struct dbr_time_short *) new_eventHandlerArgs.dbr)->status;
00524 c.alarmSeverity=((struct dbr_time_short *) new_eventHandlerArgs.dbr)->severity;
00525 c.ts =((struct dbr_time_short *) new_eventHandlerArgs.dbr)->stamp;
00526
00527 break;
00528
00529 case DBR_TIME_STRING:
00530
00531 for (long i=0; i<new_eventHandlerArgs.count; ++i) {
00532 strcpy ((*(&((c.dataBuffer)->tstrval.value)+i)) ,
00533 (*(&(((union db_access_val *) new_eventHandlerArgs.dbr)->tstrval.value)+i)) );
00534 }
00535
00536
00537 (*(&((c.dataBuffer)->tstrval.status))) = ((struct dbr_time_string *) new_eventHandlerArgs.dbr)->status;
00538 (*(&((c.dataBuffer)->tstrval.severity))) = ((struct dbr_time_string *) new_eventHandlerArgs.dbr)->severity;
00539 (*(&((c.dataBuffer)->tstrval.stamp))) = ((struct dbr_time_string *) new_eventHandlerArgs.dbr)->stamp;
00540
00541 c.alarmStatus =((struct dbr_time_string *) new_eventHandlerArgs.dbr)->status;
00542 c.alarmSeverity=((struct dbr_time_string *) new_eventHandlerArgs.dbr)->severity;
00543 c.ts =((struct dbr_time_string *) new_eventHandlerArgs.dbr)->stamp;
00544
00545 break;
00546
00547 case DBR_TIME_ENUM:
00548
00549 for (long i=0; i<new_eventHandlerArgs.count; ++i) {
00550 (*(&((c.dataBuffer)->tenmval.value)+i))
00551 = (*(&(((union db_access_val *) new_eventHandlerArgs.dbr)->tenmval.value)+i));
00552 }
00553
00554
00555 (*(&((c.dataBuffer)->tenmval.status))) = ((struct dbr_time_enum *) new_eventHandlerArgs.dbr)->status;
00556 (*(&((c.dataBuffer)->tenmval.severity))) = ((struct dbr_time_enum *) new_eventHandlerArgs.dbr)->severity;
00557 (*(&((c.dataBuffer)->tenmval.stamp))) = ((struct dbr_time_enum *) new_eventHandlerArgs.dbr)->stamp;
00558
00559 c.alarmStatus =((struct dbr_time_enum *) new_eventHandlerArgs.dbr)->status;
00560 c.alarmSeverity=((struct dbr_time_enum *) new_eventHandlerArgs.dbr)->severity;
00561 c.ts =((struct dbr_time_enum *) new_eventHandlerArgs.dbr)->stamp;
00562
00563 break;
00564
00565 case DBR_TIME_CHAR:
00566
00567 for (long i=0; i<new_eventHandlerArgs.count; ++i) {
00568 (*(&((c.dataBuffer)->tchrval.value)+i))
00569 = (*(&(((union db_access_val *) new_eventHandlerArgs.dbr)->tchrval.value)+i));
00570
00571 }
00572 (*(&((c.dataBuffer)->tchrval.status))) = ((struct dbr_time_char *) new_eventHandlerArgs.dbr)->status;
00573 (*(&((c.dataBuffer)->tchrval.severity))) = ((struct dbr_time_char *) new_eventHandlerArgs.dbr)->severity;
00574 (*(&((c.dataBuffer)->tchrval.stamp))) = ((struct dbr_time_char *) new_eventHandlerArgs.dbr)->stamp;
00575
00576 c.alarmStatus =((struct dbr_time_char *) new_eventHandlerArgs.dbr)->status;
00577 c.alarmSeverity=((struct dbr_time_char *) new_eventHandlerArgs.dbr)->severity;
00578 c.ts =((struct dbr_time_char *) new_eventHandlerArgs.dbr)->stamp;
00579 break;
00580
00581 case DBR_CTRL_DOUBLE:
00582
00583 for (long i=0; i<new_eventHandlerArgs.count; ++i) {
00584 (*(&((c.ctrlBuffer)->cdblval.value)+i)) =
00585 (*(&( ((union db_access_val *) new_eventHandlerArgs.dbr)->cdblval.value)+i));
00586 }
00587
00588 (*(&((c.ctrlBuffer)->cdblval.status))) =
00589 ((struct dbr_ctrl_double *) new_eventHandlerArgs.dbr)->status;
00590 (*(&((c.ctrlBuffer)->cdblval.severity))) =
00591 ((struct dbr_ctrl_double *) new_eventHandlerArgs.dbr)->severity;
00592 (*(&((c.ctrlBuffer)->cdblval.precision))) =
00593 ((struct dbr_ctrl_double *) new_eventHandlerArgs.dbr)->precision;
00594 (*(&((c.ctrlBuffer)->cdblval.RISC_pad0))) =
00595 (dbr_short_t) ((struct dbr_ctrl_double *) new_eventHandlerArgs.dbr)->RISC_pad0;
00596 memcpy((*(&((c.ctrlBuffer)->cdblval.units))),
00597 &(((struct dbr_ctrl_double *) new_eventHandlerArgs.dbr)->units),
00598 sizeof(char[MAX_UNITS_SIZE]));
00599 (*(&((c.ctrlBuffer)->cdblval.upper_disp_limit))) =
00600 ((struct dbr_ctrl_double *) new_eventHandlerArgs.dbr)->upper_disp_limit;
00601 (*(&((c.ctrlBuffer)->cdblval.lower_disp_limit))) =
00602 ((struct dbr_ctrl_double *) new_eventHandlerArgs.dbr)->lower_disp_limit;
00603 (*(&((c.ctrlBuffer)->cdblval.upper_alarm_limit))) =
00604 ((struct dbr_ctrl_double *) new_eventHandlerArgs.dbr)->upper_alarm_limit;
00605 (*(&((c.ctrlBuffer)->cdblval.upper_warning_limit))) =
00606 ((struct dbr_ctrl_double *) new_eventHandlerArgs.dbr)->upper_warning_limit;
00607 (*(&((c.ctrlBuffer)->cdblval.lower_warning_limit))) =
00608 ((struct dbr_ctrl_double *) new_eventHandlerArgs.dbr)->lower_warning_limit;
00609 (*(&((c.ctrlBuffer)->cdblval.lower_alarm_limit))) =
00610 ((struct dbr_ctrl_double *) new_eventHandlerArgs.dbr)->lower_alarm_limit;
00611 (*(&((c.ctrlBuffer)->cdblval.upper_ctrl_limit))) =
00612 ((struct dbr_ctrl_double *) new_eventHandlerArgs.dbr)->upper_ctrl_limit;
00613 (*(&((c.ctrlBuffer)->cdblval.lower_ctrl_limit))) =
00614 ((struct dbr_ctrl_double *) new_eventHandlerArgs.dbr)->lower_ctrl_limit;
00615
00616 break;
00617
00618 case DBR_CTRL_LONG:
00619
00620 for (long i=0; i<new_eventHandlerArgs.count; ++i) {
00621 (*(&((c.ctrlBuffer)->clngval.value)+i)) =
00622 (*(&( ((union db_access_val *) new_eventHandlerArgs.dbr)->clngval.value)+i));
00623 }
00624
00625 (*(&((c.ctrlBuffer)->clngval.status))) =
00626 ((struct dbr_ctrl_long *) new_eventHandlerArgs.dbr)->status;
00627 (*(&((c.ctrlBuffer)->clngval.severity))) =
00628 ((struct dbr_ctrl_long *) new_eventHandlerArgs.dbr)->severity;
00629
00630
00631
00632 memcpy((*(&((c.ctrlBuffer)->clngval.units))),
00633 &(((struct dbr_ctrl_long *) new_eventHandlerArgs.dbr)->units),
00634 sizeof(char[MAX_UNITS_SIZE]));
00635
00636 (*(&((c.ctrlBuffer)->clngval.upper_disp_limit))) =
00637 ((struct dbr_ctrl_long *) new_eventHandlerArgs.dbr)->upper_disp_limit;
00638 (*(&((c.ctrlBuffer)->clngval.lower_disp_limit))) =
00639 ((struct dbr_ctrl_long *) new_eventHandlerArgs.dbr)->lower_disp_limit;
00640 (*(&((c.ctrlBuffer)->clngval.upper_alarm_limit))) =
00641 ((struct dbr_ctrl_long *) new_eventHandlerArgs.dbr)->upper_alarm_limit;
00642 (*(&((c.ctrlBuffer)->clngval.upper_warning_limit))) =
00643 ((struct dbr_ctrl_long *) new_eventHandlerArgs.dbr)->upper_warning_limit;
00644 (*(&((c.ctrlBuffer)->clngval.lower_warning_limit))) =
00645 ((struct dbr_ctrl_long *) new_eventHandlerArgs.dbr)->lower_warning_limit;
00646 (*(&((c.ctrlBuffer)->clngval.lower_alarm_limit))) =
00647 ((struct dbr_ctrl_long *) new_eventHandlerArgs.dbr)->lower_alarm_limit;
00648 (*(&((c.ctrlBuffer)->clngval.upper_ctrl_limit))) =
00649 ((struct dbr_ctrl_long *) new_eventHandlerArgs.dbr)->upper_ctrl_limit;
00650 (*(&((c.ctrlBuffer)->clngval.lower_ctrl_limit))) =
00651 ((struct dbr_ctrl_long *) new_eventHandlerArgs.dbr)->lower_ctrl_limit;
00652
00653
00654
00655
00656 break;
00657
00658
00659 case DBR_CTRL_CHAR:
00660
00661 for (long i=0; i<new_eventHandlerArgs.count; ++i) {
00662 (*(&((c.ctrlBuffer)->gchrval.value)+i)) =
00663 (*(&( ((union db_access_val *) new_eventHandlerArgs.dbr)->cchrval.value)+i));
00664 }
00665
00666 (*(&((c.ctrlBuffer)->cchrval.status))) =
00667 ((struct dbr_ctrl_char *) new_eventHandlerArgs.dbr)->status;
00668 (*(&((c.ctrlBuffer)->cchrval.severity))) =
00669 ((struct dbr_ctrl_char *) new_eventHandlerArgs.dbr)->severity;
00670
00671
00672
00673 memcpy((*(&((c.ctrlBuffer)->cchrval.units))),
00674 &(((struct dbr_ctrl_char *) new_eventHandlerArgs.dbr)->units),
00675 sizeof(char[MAX_UNITS_SIZE]));
00676
00677 (*(&((c.ctrlBuffer)->cchrval.upper_disp_limit))) =
00678 ((struct dbr_ctrl_char *) new_eventHandlerArgs.dbr)->upper_disp_limit;
00679 (*(&((c.ctrlBuffer)->cchrval.lower_disp_limit))) =
00680 ((struct dbr_ctrl_char *) new_eventHandlerArgs.dbr)->lower_disp_limit;
00681 (*(&((c.ctrlBuffer)->cchrval.upper_alarm_limit))) =
00682 ((struct dbr_ctrl_char *) new_eventHandlerArgs.dbr)->upper_alarm_limit;
00683 (*(&((c.ctrlBuffer)->cchrval.upper_warning_limit))) =
00684 ((struct dbr_ctrl_char *) new_eventHandlerArgs.dbr)->upper_warning_limit;
00685 (*(&((c.ctrlBuffer)->cchrval.lower_warning_limit))) =
00686 ((struct dbr_ctrl_char *) new_eventHandlerArgs.dbr)->lower_warning_limit;
00687 (*(&((c.ctrlBuffer)->cchrval.lower_alarm_limit))) =
00688 ((struct dbr_ctrl_char *) new_eventHandlerArgs.dbr)->lower_alarm_limit;
00689 (*(&((c.ctrlBuffer)->cchrval.upper_ctrl_limit))) =
00690 ((struct dbr_ctrl_char *) new_eventHandlerArgs.dbr)->upper_ctrl_limit;
00691 (*(&((c.ctrlBuffer)->cchrval.lower_ctrl_limit))) =
00692 ((struct dbr_ctrl_char *) new_eventHandlerArgs.dbr)->lower_ctrl_limit;
00693
00694
00695
00696
00697 break;
00698
00699
00700 case DBR_CTRL_ENUM:
00701
00702 for (long i=0; i<new_eventHandlerArgs.count; ++i){
00703 (*(&((c.ctrlBuffer)->cenmval.value)+i)) =
00704 (*(&( ((union db_access_val *) new_eventHandlerArgs.dbr)->cenmval.value)+i));
00705 }
00706
00707 (*(&((c.ctrlBuffer)->cenmval.status))) =
00708 ((struct dbr_ctrl_enum *) new_eventHandlerArgs.dbr)->status;
00709 (*(&((c.ctrlBuffer)->cenmval.severity))) =
00710 ((struct dbr_ctrl_enum *) new_eventHandlerArgs.dbr)->severity;
00711
00712
00713
00714
00715
00716 (*(&((c.ctrlBuffer)->cenmval.no_str))) =
00717 ((struct dbr_ctrl_enum *) new_eventHandlerArgs.dbr)->no_str;
00718
00719 memcpy( (*(&((c.ctrlBuffer)->cenmval.strs))),
00720 &(((struct dbr_ctrl_enum *) new_eventHandlerArgs.dbr)->strs),
00721 sizeof(char)*MAX_ENUM_STRING_SIZE*MAX_ENUM_STATES) ;
00722
00723
00724
00725 memcpy(c.channelEnumStrings.options, &(((struct dbr_ctrl_enum *) new_eventHandlerArgs.dbr)->strs),
00726 sizeof(c.channelEnumStrings.options));
00727 c.channelEnumStrings.noOptions=((struct dbr_ctrl_enum *) new_eventHandlerArgs.dbr)->no_str;
00728
00729
00730
00731 break;
00732
00733
00734 case DBR_CTRL_FLOAT:
00735
00736 for (long i=0; i<new_eventHandlerArgs.count; ++i) {
00737 (*(&((c.ctrlBuffer)->cfltval.value)+i)) =
00738 (*(&( ((union db_access_val *) new_eventHandlerArgs.dbr)->cfltval.value)+i));
00739 }
00740
00741 (*(&((c.ctrlBuffer)->cfltval.status))) =
00742 ((struct dbr_ctrl_float *) new_eventHandlerArgs.dbr)->status;
00743 (*(&((c.ctrlBuffer)->cfltval.severity))) =
00744 ((struct dbr_ctrl_float *) new_eventHandlerArgs.dbr)->severity;
00745
00746
00747 (*(&((c.ctrlBuffer)->cfltval.precision))) =
00748 ((struct dbr_ctrl_float *) new_eventHandlerArgs.dbr)->precision;
00749 (*(&((c.ctrlBuffer)->cfltval.RISC_pad))) = (dbr_short_t)
00750 ((struct dbr_ctrl_float *) new_eventHandlerArgs.dbr)->RISC_pad;
00751
00752 memcpy((*(&((c.ctrlBuffer)->cfltval.units))),
00753 &(((struct dbr_ctrl_float *) new_eventHandlerArgs.dbr)->units),
00754 sizeof(char[MAX_UNITS_SIZE]));
00755
00756 (*(&((c.ctrlBuffer)->cfltval.upper_disp_limit))) =
00757 ((struct dbr_ctrl_float *) new_eventHandlerArgs.dbr)->upper_disp_limit;
00758 (*(&((c.ctrlBuffer)->cfltval.lower_disp_limit))) =
00759 ((struct dbr_ctrl_float *) new_eventHandlerArgs.dbr)->lower_disp_limit;
00760 (*(&((c.ctrlBuffer)->cfltval.upper_alarm_limit))) =
00761 ((struct dbr_ctrl_float *) new_eventHandlerArgs.dbr)->upper_alarm_limit;
00762 (*(&((c.ctrlBuffer)->cfltval.upper_warning_limit))) =
00763 ((struct dbr_ctrl_float *) new_eventHandlerArgs.dbr)->upper_warning_limit;
00764 (*(&((c.ctrlBuffer)->cfltval.lower_warning_limit))) =
00765 ((struct dbr_ctrl_float *) new_eventHandlerArgs.dbr)->lower_warning_limit;
00766 (*(&((c.ctrlBuffer)->cfltval.lower_alarm_limit))) =
00767 ((struct dbr_ctrl_float *) new_eventHandlerArgs.dbr)->lower_alarm_limit;
00768 (*(&((c.ctrlBuffer)->cfltval.upper_ctrl_limit))) =
00769 ((struct dbr_ctrl_float *) new_eventHandlerArgs.dbr)->upper_ctrl_limit;
00770 (*(&((c.ctrlBuffer)->cfltval.lower_ctrl_limit))) =
00771 ((struct dbr_ctrl_float *) new_eventHandlerArgs.dbr)->lower_ctrl_limit;
00772
00773
00774
00775
00776
00777 break;
00778
00779
00780 case DBR_CTRL_SHORT:
00781
00782 for (long i=0; i<new_eventHandlerArgs.count; ++i) {
00783 (*(&((c.ctrlBuffer)->gshrtval.value)+i)) =
00784 (*(&( ((union db_access_val *) new_eventHandlerArgs.dbr)->cshrtval.value)+i));
00785 }
00786
00787 (*(&((c.ctrlBuffer)->cshrtval.status))) =
00788 ((struct dbr_ctrl_short *) new_eventHandlerArgs.dbr)->status;
00789 (*(&((c.ctrlBuffer)->cshrtval.severity))) =
00790 ((struct dbr_ctrl_short *) new_eventHandlerArgs.dbr)->severity;
00791
00792
00793
00794 memcpy((*(&((c.ctrlBuffer)->cshrtval.units))),
00795 &(((struct dbr_ctrl_short *) new_eventHandlerArgs.dbr)->units),
00796 sizeof(char[MAX_UNITS_SIZE]));
00797
00798 (*(&((c.ctrlBuffer)->cshrtval.upper_disp_limit))) =
00799 ((struct dbr_ctrl_short *) new_eventHandlerArgs.dbr)->upper_disp_limit;
00800 (*(&((c.ctrlBuffer)->cshrtval.lower_disp_limit))) =
00801 ((struct dbr_ctrl_short *) new_eventHandlerArgs.dbr)->lower_disp_limit;
00802 (*(&((c.ctrlBuffer)->cshrtval.upper_alarm_limit))) =
00803 ((struct dbr_ctrl_short *) new_eventHandlerArgs.dbr)->upper_alarm_limit;
00804 (*(&((c.ctrlBuffer)->cshrtval.upper_warning_limit))) =
00805 ((struct dbr_ctrl_short *) new_eventHandlerArgs.dbr)->upper_warning_limit;
00806 (*(&((c.ctrlBuffer)->cshrtval.lower_warning_limit))) =
00807 ((struct dbr_ctrl_short *) new_eventHandlerArgs.dbr)->lower_warning_limit;
00808 (*(&((c.ctrlBuffer)->cshrtval.lower_alarm_limit))) =
00809 ((struct dbr_ctrl_short *) new_eventHandlerArgs.dbr)->lower_alarm_limit;
00810 (*(&((c.ctrlBuffer)->cshrtval.upper_ctrl_limit))) =
00811 ((struct dbr_ctrl_short *) new_eventHandlerArgs.dbr)->upper_ctrl_limit;
00812 (*(&((c.ctrlBuffer)->cshrtval.lower_ctrl_limit))) =
00813 ((struct dbr_ctrl_short *) new_eventHandlerArgs.dbr)->lower_ctrl_limit;
00814
00815
00816
00817
00818
00819 break;
00820
00821
00822 case DBR_CTRL_STRING:
00823
00824 for (long i=0; i<new_eventHandlerArgs.count; ++i){
00825 strcpy( (*(&((c.ctrlBuffer)->cstrval.value)+i)),
00826 (*(&( ((union db_access_val *) new_eventHandlerArgs.dbr)->cstrval.value)+i)));
00827 }
00828
00829 (*(&((c.ctrlBuffer)->cstrval.status))) =
00830 ((struct dbr_sts_string *) new_eventHandlerArgs.dbr)->status;
00831 (*(&((c.ctrlBuffer)->cstrval.severity))) =
00832 ((struct dbr_sts_short *) new_eventHandlerArgs.dbr)->severity;
00833
00834
00835
00836
00837 break;
00838
00839 case DBR_GR_DOUBLE:
00840
00841 for (long i=0; i<new_eventHandlerArgs.count; ++i) {
00842 (*(&((c.ctrlBuffer)->gdblval.value)+i)) =
00843 (*(&( ((union db_access_val *) new_eventHandlerArgs.dbr)->gdblval.value)+i));
00844 }
00845
00846 (*(&((c.ctrlBuffer)->gdblval.status))) =
00847 ((struct dbr_gr_double *) new_eventHandlerArgs.dbr)->status;
00848 (*(&((c.ctrlBuffer)->gdblval.severity))) =
00849 ((struct dbr_gr_double *) new_eventHandlerArgs.dbr)->severity;
00850
00851 (*(&((c.ctrlBuffer)->gdblval.precision))) =
00852 ((struct dbr_gr_double *) new_eventHandlerArgs.dbr)->precision;
00853
00854 (*(&((c.ctrlBuffer)->gdblval.RISC_pad0))) =
00855 (dbr_short_t) ((struct dbr_gr_double *) new_eventHandlerArgs.dbr)->RISC_pad0;
00856
00857 memcpy((*(&((c.ctrlBuffer)->gdblval.units))),
00858 &(((struct dbr_gr_double *) new_eventHandlerArgs.dbr)->units),
00859 sizeof(char[MAX_UNITS_SIZE]));
00860
00861 (*(&((c.ctrlBuffer)->gdblval.upper_disp_limit))) =
00862 ((struct dbr_gr_double *) new_eventHandlerArgs.dbr)->upper_disp_limit;
00863 (*(&((c.ctrlBuffer)->gdblval.lower_disp_limit))) =
00864 ((struct dbr_gr_double *) new_eventHandlerArgs.dbr)->lower_disp_limit;
00865 (*(&((c.ctrlBuffer)->gdblval.upper_alarm_limit))) =
00866 ((struct dbr_gr_double *) new_eventHandlerArgs.dbr)->upper_alarm_limit;
00867 (*(&((c.ctrlBuffer)->gdblval.upper_warning_limit))) =
00868 ((struct dbr_gr_double *) new_eventHandlerArgs.dbr)->upper_warning_limit;
00869 (*(&((c.ctrlBuffer)->gdblval.lower_warning_limit))) =
00870 ((struct dbr_gr_double *) new_eventHandlerArgs.dbr)->lower_warning_limit;
00871 (*(&((c.ctrlBuffer)->gdblval.lower_alarm_limit))) =
00872 ((struct dbr_gr_double *) new_eventHandlerArgs.dbr)->lower_alarm_limit;
00873
00874
00875
00876
00877 break;
00878
00879 case DBR_GR_LONG:
00880
00881 for (long i=0; i<new_eventHandlerArgs.count; ++i) {
00882 (*(&((c.ctrlBuffer)->glngval.value)+i)) =
00883 (*(&( ((union db_access_val *) new_eventHandlerArgs.dbr)->glngval.value)+i));
00884 }
00885
00886 (*(&((c.ctrlBuffer)->glngval.status))) =
00887 ((struct dbr_gr_long *) new_eventHandlerArgs.dbr)->status;
00888 (*(&((c.ctrlBuffer)->glngval.severity))) =
00889 ((struct dbr_gr_long *) new_eventHandlerArgs.dbr)->severity;
00890
00891
00892
00893 memcpy((*(&((c.ctrlBuffer)->glngval.units))),
00894 &(((struct dbr_gr_long *) new_eventHandlerArgs.dbr)->units),
00895 sizeof(char[MAX_UNITS_SIZE]));
00896
00897 (*(&((c.ctrlBuffer)->glngval.upper_disp_limit))) =
00898 ((struct dbr_gr_long *) new_eventHandlerArgs.dbr)->upper_disp_limit;
00899 (*(&((c.ctrlBuffer)->glngval.lower_disp_limit))) =
00900 ((struct dbr_gr_long *) new_eventHandlerArgs.dbr)->lower_disp_limit;
00901 (*(&((c.ctrlBuffer)->glngval.upper_alarm_limit))) =
00902 ((struct dbr_gr_long *) new_eventHandlerArgs.dbr)->upper_alarm_limit;
00903 (*(&((c.ctrlBuffer)->glngval.upper_warning_limit))) =
00904 ((struct dbr_gr_long *) new_eventHandlerArgs.dbr)->upper_warning_limit;
00905 (*(&((c.ctrlBuffer)->glngval.lower_warning_limit))) =
00906 ((struct dbr_gr_long *) new_eventHandlerArgs.dbr)->lower_warning_limit;
00907 (*(&((c.ctrlBuffer)->glngval.lower_alarm_limit))) =
00908 ((struct dbr_gr_long *) new_eventHandlerArgs.dbr)->lower_alarm_limit;
00909
00910
00911
00912
00913 break;
00914
00915
00916 case DBR_GR_CHAR:
00917
00918 for (long i=0; i<new_eventHandlerArgs.count; ++i) {
00919 (*(&((c.ctrlBuffer)->gchrval.value)+i)) =
00920 (*(&( ((union db_access_val *) new_eventHandlerArgs.dbr)->gchrval.value)+i));
00921 }
00922
00923 (*(&((c.ctrlBuffer)->gchrval.status))) =
00924 ((struct dbr_gr_char *) new_eventHandlerArgs.dbr)->status;
00925 (*(&((c.ctrlBuffer)->gchrval.severity))) =
00926 ((struct dbr_gr_char *) new_eventHandlerArgs.dbr)->severity;
00927
00928
00929
00930 memcpy((*(&((c.ctrlBuffer)->gchrval.units))),
00931 &(((struct dbr_gr_char *) new_eventHandlerArgs.dbr)->units),
00932 sizeof(char[MAX_UNITS_SIZE]));
00933
00934 (*(&((c.ctrlBuffer)->gchrval.upper_disp_limit))) =
00935 ((struct dbr_gr_char *) new_eventHandlerArgs.dbr)->upper_disp_limit;
00936 (*(&((c.ctrlBuffer)->gchrval.lower_disp_limit))) =
00937 ((struct dbr_gr_char *) new_eventHandlerArgs.dbr)->lower_disp_limit;
00938 (*(&((c.ctrlBuffer)->gchrval.upper_alarm_limit))) =
00939 ((struct dbr_gr_char *) new_eventHandlerArgs.dbr)->upper_alarm_limit;
00940 (*(&((c.ctrlBuffer)->gchrval.upper_warning_limit))) =
00941 ((struct dbr_gr_char *) new_eventHandlerArgs.dbr)->upper_warning_limit;
00942 (*(&((c.ctrlBuffer)->gchrval.lower_warning_limit))) =
00943 ((struct dbr_gr_char *) new_eventHandlerArgs.dbr)->lower_warning_limit;
00944 (*(&((c.ctrlBuffer)->gchrval.lower_alarm_limit))) =
00945 ((struct dbr_gr_char *) new_eventHandlerArgs.dbr)->lower_alarm_limit;
00946
00947
00948
00949
00950 break;
00951
00952
00953 case DBR_GR_ENUM:
00954
00955 for (long i=0; i<new_eventHandlerArgs.count; ++i){
00956 (*(&((c.ctrlBuffer)->genmval.value)+i)) =
00957 (*(&( ((union db_access_val *) new_eventHandlerArgs.dbr)->genmval.value)+i));
00958 }
00959
00960 (*(&((c.ctrlBuffer)->genmval.status))) =
00961 ((struct dbr_gr_enum *) new_eventHandlerArgs.dbr)->status;
00962 (*(&((c.ctrlBuffer)->genmval.severity))) =
00963 ((struct dbr_gr_enum *) new_eventHandlerArgs.dbr)->severity;
00964
00965
00966
00967
00968
00969 (*(&((c.ctrlBuffer)->genmval.no_str))) =
00970 ((struct dbr_gr_enum *) new_eventHandlerArgs.dbr)->no_str;
00971
00972 memcpy( (*(&((c.ctrlBuffer)->genmval.strs))),
00973 &(((struct dbr_gr_enum *) new_eventHandlerArgs.dbr)->strs),
00974 sizeof(char)*MAX_ENUM_STRING_SIZE*MAX_ENUM_STATES) ;
00975
00976
00977
00978
00979 memcpy(c.channelEnumStrings.options, &(((struct dbr_gr_enum *) new_eventHandlerArgs.dbr)->strs),
00980 sizeof(c.channelEnumStrings.options));
00981 c.channelEnumStrings.noOptions=((struct dbr_gr_enum *) new_eventHandlerArgs.dbr)->no_str;
00982
00983
00984
00985 break;
00986
00987
00988 case DBR_GR_FLOAT:
00989
00990 for (long i=0; i<new_eventHandlerArgs.count; ++i) {
00991 (*(&((c.ctrlBuffer)->gfltval.value)+i)) =
00992 (*(&( ((union db_access_val *) new_eventHandlerArgs.dbr)->gfltval.value)+i));
00993 }
00994
00995 (*(&((c.ctrlBuffer)->gfltval.status))) =
00996 ((struct dbr_gr_float *) new_eventHandlerArgs.dbr)->status;
00997 (*(&((c.ctrlBuffer)->gfltval.severity))) =
00998 ((struct dbr_gr_float *) new_eventHandlerArgs.dbr)->severity;
00999
01000
01001 (*(&((c.ctrlBuffer)->gfltval.precision))) =
01002 ((struct dbr_gr_float *) new_eventHandlerArgs.dbr)->precision;
01003 (*(&((c.ctrlBuffer)->gfltval.RISC_pad0))) =
01004 (dbr_short_t) ((struct dbr_gr_float *) new_eventHandlerArgs.dbr)->RISC_pad0;
01005
01006 memcpy((*(&((c.ctrlBuffer)->gfltval.units))),
01007 &(((struct dbr_gr_float *) new_eventHandlerArgs.dbr)->units),
01008 sizeof(char[MAX_UNITS_SIZE]));
01009
01010 (*(&((c.ctrlBuffer)->gfltval.upper_disp_limit))) =
01011 ((struct dbr_gr_float *) new_eventHandlerArgs.dbr)->upper_disp_limit;
01012 (*(&((c.ctrlBuffer)->gfltval.lower_disp_limit))) =
01013 ((struct dbr_gr_float *) new_eventHandlerArgs.dbr)->lower_disp_limit;
01014 (*(&((c.ctrlBuffer)->gfltval.upper_alarm_limit))) =
01015 ((struct dbr_gr_float *) new_eventHandlerArgs.dbr)->upper_alarm_limit;
01016 (*(&((c.ctrlBuffer)->gfltval.upper_warning_limit))) =
01017 ((struct dbr_gr_float *) new_eventHandlerArgs.dbr)->upper_warning_limit;
01018 (*(&((c.ctrlBuffer)->gfltval.lower_warning_limit))) =
01019 ((struct dbr_gr_float *) new_eventHandlerArgs.dbr)->lower_warning_limit;
01020 (*(&((c.ctrlBuffer)->gfltval.lower_alarm_limit))) =
01021 ((struct dbr_gr_float *) new_eventHandlerArgs.dbr)->lower_alarm_limit;
01022
01023
01024
01025
01026
01027 break;
01028
01029
01030 case DBR_GR_SHORT:
01031
01032 for (long i=0; i<new_eventHandlerArgs.count; ++i) {
01033 (*(&((c.ctrlBuffer)->gshrtval.value)+i)) =
01034 (*(&( ((union db_access_val *) new_eventHandlerArgs.dbr)->gshrtval.value)+i));
01035 }
01036
01037 (*(&((c.ctrlBuffer)->gshrtval.status))) =
01038 ((struct dbr_gr_short *) new_eventHandlerArgs.dbr)->status;
01039 (*(&((c.ctrlBuffer)->gshrtval.severity))) =
01040 ((struct dbr_gr_short *) new_eventHandlerArgs.dbr)->severity;
01041
01042
01043
01044 memcpy((*(&((c.ctrlBuffer)->gshrtval.units))),
01045 &(((struct dbr_gr_short *) new_eventHandlerArgs.dbr)->units),
01046 sizeof(char[MAX_UNITS_SIZE]));
01047
01048 (*(&((c.ctrlBuffer)->gshrtval.upper_disp_limit))) =
01049 ((struct dbr_gr_short *) new_eventHandlerArgs.dbr)->upper_disp_limit;
01050 (*(&((c.ctrlBuffer)->gshrtval.lower_disp_limit))) =
01051 ((struct dbr_gr_short *) new_eventHandlerArgs.dbr)->lower_disp_limit;
01052 (*(&((c.ctrlBuffer)->gshrtval.upper_alarm_limit))) =
01053 ((struct dbr_gr_short *) new_eventHandlerArgs.dbr)->upper_alarm_limit;
01054 (*(&((c.ctrlBuffer)->gshrtval.upper_warning_limit))) =
01055 ((struct dbr_gr_short *) new_eventHandlerArgs.dbr)->upper_warning_limit;
01056 (*(&((c.ctrlBuffer)->gshrtval.lower_warning_limit))) =
01057 ((struct dbr_gr_short *) new_eventHandlerArgs.dbr)->lower_warning_limit;
01058 (*(&((c.ctrlBuffer)->gshrtval.lower_alarm_limit))) =
01059 ((struct dbr_gr_short *) new_eventHandlerArgs.dbr)->lower_alarm_limit;
01060
01061
01062
01063
01064 break;
01065
01066
01067 case DBR_GR_STRING:
01068
01069 for (long i=0; i<new_eventHandlerArgs.count; ++i){
01070 strcpy( (*(&((c.ctrlBuffer)->gstrval.value)+i)),
01071 (*(&( ((union db_access_val *) new_eventHandlerArgs.dbr)->gstrval.value)+i)));
01072 }
01073
01074 (*(&((c.ctrlBuffer)->gstrval.status))) =
01075 ((struct dbr_sts_string *) new_eventHandlerArgs.dbr)->status;
01076 (*(&((c.ctrlBuffer)->gstrval.severity))) =
01077 ((struct dbr_sts_short *) new_eventHandlerArgs.dbr)->severity;
01078
01079
01080
01081
01082 break;
01083
01084 case DBR_STSACK_STRING:
01085
01086
01087
01088
01089
01090
01091
01092
01093
01094
01095
01096
01097
01098
01099
01100 for (long i=0; i<new_eventHandlerArgs.count; ++i) {
01101 strcpy ((*(&((c.stsackBuffer)->sastrval.value)+i)) ,
01102 (*(&(((struct dbr_stsack_string *) new_eventHandlerArgs.dbr)->value)+i)) );
01103
01104 }
01105
01106
01107
01108 (*(&((c.stsackBuffer)->sastrval.status))) = (dbr_ushort_t) ((struct dbr_stsack_string *) new_eventHandlerArgs.dbr)->status;
01109 (*(&((c.stsackBuffer)->sastrval.severity))) = (dbr_ushort_t) ((struct dbr_stsack_string *) new_eventHandlerArgs.dbr)->severity;
01110
01111
01112
01113
01114
01115
01116
01117
01118
01119
01120
01121
01122
01123
01124
01125
01126
01127
01128
01129 break;
01130
01131 case DBR_CLASS_NAME:
01132
01133
01134
01135
01136
01137
01138
01139
01140
01141
01142
01143
01144
01146 strcpy( c.channelRegalia.className,
01147 (*(&(((union db_access_val *) new_eventHandlerArgs.dbr)->classname)+0)));
01148
01149
01150
01151 break;
01152
01153
01154 default:
01155 cout << "CAFE INTERNAL ERROR: This line should never appear! " << endl;
01156 cout << __FILE__ << "/" << __LINE__ << "/" << __METHOD__ << endl;
01157 cout << "Method does not support this DBR_TYPE: "
01158 << dbr_type_to_text(new_eventHandlerArgs.type) << endl;
01159
01160
01161
01162 }
01163
01164
01165
01166
01167 if(c.ts.nsec>1000000000) {c.ts.nsec=0;}
01168
01169
01170
01171 }
01172
01173
01174
01175 private:
01176 event_handler_args new_eventHandlerArgs;
01177 #undef __METHOD__
01178 };
01179
01180
01182
01183
01184 #endif // CONDUITEVENTHANDLERARGS_H