00001
00002
00003
00004
00005
00006
00008
00009 #include <string>
00010 #include <vector>
00011 #include <algorithm>
00012
00013 #include <ipc/partition.h>
00014
00015 #include <is/isinfoany.h>
00016 #include <is/isnamedinfo.h>
00017 #include <unistd.h>
00018
00019 using namespace std;
00020
00021 #include "sctddc/SCTDdcRequest.hxx"
00022
00023 SCTDdcRequest::SCTDdcRequest(IPCPartition& partition, string& isServer)
00024 : m_requestReady(false), m_partition(partition), m_requestServer(isServer)
00025 {
00026 m_infoReceiver = new ISInfoReceiver(partition);
00027 }
00028
00029
00030 void SCTDdcRequest::requestReady_vec_init(unsigned int vecSize)
00031 {
00032
00033 m_requestReady_vec_index = 0;
00034
00035 m_requestReady_vec.erase(m_requestReady_vec.begin(), m_requestReady_vec.end());
00036
00037 for(unsigned int i=0; i<vecSize; i++)
00038 m_requestReady_vec.push_back(false);
00039
00040 m_floatVecRequestResponse.erase(m_floatVecRequestResponse.begin(),
00041 m_floatVecRequestResponse.end());
00042 }
00043
00044
00045 bool SCTDdcRequest::getRequestReady_vec()
00046 {
00047 bool allRequestReady = true;
00048 for(unsigned int i=0; i<m_requestReady_vec.size(); i++)
00049 allRequestReady = allRequestReady && m_requestReady_vec[i];
00050 return allRequestReady;
00051 }
00052
00053
00054 void SCTDdcRequest::setRequestReady_vec(bool request)
00055 {
00056 m_requestReady_vec[m_requestReady_vec_index] = request;
00057 m_requestReady_vec_index++;
00058 }
00059
00060 void requestCallback(ISCallbackInfo* isCallback)
00061
00062 {
00063 std::string value_str;
00064 OWLDate value_date;
00065 OWLTime value_time;
00066
00067 SCTDdcRequest* sctDdcRequest = (SCTDdcRequest*)(isCallback->parameter());
00068
00069
00070 ISInfoAny dcsData;
00071 if(isCallback->reason() != ISInfoDeleted)
00072 {
00073 string dpeName = isCallback->name();
00074 isCallback->value(dcsData);
00075 }
00076
00077 int N = dcsData.countAttributes( );
00078
00079
00080 for (int i=0; i<N; i++)
00081 {
00082 switch(dcsData.getAttributeType())
00083 {
00084 case ISType::Boolean:
00085
00086 bool value_bool;
00087 dcsData >> value_bool;
00088 sctDdcRequest->setIntRequestResponse(int(value_bool));
00089 sctDdcRequest->setFloatRequestResponse(float(value_bool));
00090 sctDdcRequest->setRequestReady(true);
00091 break;
00092 case ISType::S8:
00093 case ISType::U8:
00094 case ISType::S16:
00095
00096 short value_s;
00097 dcsData >> value_s;
00098 sctDdcRequest->setIntRequestResponse(int(value_s));
00099 sctDdcRequest->setFloatRequestResponse(float(value_s));
00100 sctDdcRequest->setRequestReady(true);
00101 break;
00102 case ISType::U16:
00103
00104 unsigned short value_us;
00105 dcsData >> value_us;
00106 sctDdcRequest->setIntRequestResponse(int(value_us));
00107 sctDdcRequest->setFloatRequestResponse(float(value_us));
00108 sctDdcRequest->setRequestReady(true);
00109 break;
00110 case ISType::S32:
00111
00112 long value_int;
00113 dcsData >> value_int;
00114 sctDdcRequest->setIntRequestResponse(value_int);
00115 sctDdcRequest->setFloatRequestResponse(float(value_int));
00116 sctDdcRequest->setRequestReady(true);
00117 break;
00118 case ISType::U32:
00119
00120 unsigned long value_uint;
00121 dcsData >> value_uint;
00122 sctDdcRequest->setIntRequestResponse(value_uint);
00123 sctDdcRequest->setFloatRequestResponse(float(value_uint));
00124 sctDdcRequest->setRequestReady(true);
00125 break;
00126 case ISType::Float:
00127
00128 float value_float;
00129 dcsData >> value_float;
00130 sctDdcRequest->setFloatRequestResponse(value_float);
00131 sctDdcRequest->setIntRequestResponse(int(value_float));
00132 sctDdcRequest->setRequestReady(true);
00133 break;
00134 case ISType::Double:
00135
00136 double value_d;
00137 dcsData >> value_d;
00138 sctDdcRequest->setFloatRequestResponse(float(value_d));
00139 sctDdcRequest->setIntRequestResponse(int(value_d));
00140 sctDdcRequest->setRequestReady(true);
00141 break;
00142 case ISType::String:
00143
00144 dcsData >> value_str;
00145 sctDdcRequest->setStringRequestResponse(value_str);
00146 sctDdcRequest->setRequestReady(true);
00147 break;
00148
00149 case ISType::Date:
00150
00151 dcsData >> value_date;
00152 std::cerr<<"SCTDdcRequest::requestCallback() DDC_ERROR: variable from dcs is date, "
00153 <<"not implemented inddcRequest class"<< std::endl;
00154 break;
00155 case ISType::Time:
00156
00157 dcsData >> value_time;
00158
00159
00160 break;
00161
00162
00163 default:
00164 cout << "SCTDdcRequest::requestCallback() DDC_ERROR: Invalid Type"
00165 << (long)dcsData.getAttributeType() << std::endl;
00166 }
00167 }
00168 }
00169
00170
00171 void floatArrayRequestCallback(ISCallbackInfo* isCallback)
00172
00173 {
00174 OWLTime value_time;
00175
00176 SCTDdcRequest* sctDdcRequest = (SCTDdcRequest*)(isCallback->parameter());
00177
00178
00179 ISInfoAny dcsData;
00180 if(isCallback->reason() != ISInfoDeleted)
00181 {
00182 string dpeName = isCallback->name();
00183 isCallback->value(dcsData);
00184 }
00185
00186
00187 dcsData >> value_time;
00188
00189
00190 float *float_array;
00191 size_t array_size;
00192
00193 dcsData.get(&float_array, array_size);
00194 sctDdcRequest->setFloatArrayRequestResponse(float_array, int(array_size));
00195 sctDdcRequest->setRequestReady(true);
00196
00197 return;
00198 }
00199
00200
00201 void requestFloatVecCallback(ISCallbackInfo* isCallback)
00202
00203 {
00204 std::string value_str;
00205 OWLDate value_date;
00206 OWLTime value_time;
00207 string dpeName;
00208
00209
00210 SCTDdcRequest* sctDdcRequest = (SCTDdcRequest*)(isCallback->parameter());
00211
00212
00213 ISInfoAny dcsData;
00214 if(isCallback->reason() != ISInfoDeleted)
00215 {
00216 dpeName = isCallback->name();
00217
00218 unsigned int position = dpeName.find(".Recv");
00219 if(position != string::npos) dpeName = dpeName.substr(0,position);
00220 position = dpeName.find(".Send");
00221 if(position != string::npos) dpeName = dpeName.substr(0,position);
00222 dpeName = dpeName.substr(dpeName.find_last_of(".")+1, dpeName.size());
00223 isCallback->value(dcsData);
00224 }
00225
00226 int N = dcsData.countAttributes( );
00227
00228
00229 for (int i=0; i<N; i++)
00230 {
00231 switch(dcsData.getAttributeType())
00232 {
00233 case ISType::Boolean:
00234
00235 bool value_bool;
00236 dcsData >> value_bool;
00237 sctDdcRequest->setfloatVecRequestResponse(dpeName, float(value_bool));
00238 sctDdcRequest->setRequestReady_vec(true);
00239 break;
00240 case ISType::S8:
00241 case ISType::U8:
00242 case ISType::S16:
00243
00244 short value_s;
00245 dcsData >> value_s;
00246 sctDdcRequest->setfloatVecRequestResponse(dpeName, float(value_s));
00247 sctDdcRequest->setRequestReady_vec(true);
00248 break;
00249 case ISType::U16:
00250
00251 unsigned short value_us;
00252 dcsData >> value_us;
00253 sctDdcRequest->setfloatVecRequestResponse(dpeName, float(value_us));
00254 sctDdcRequest->setRequestReady_vec(true);
00255 break;
00256 case ISType::S32:
00257
00258 long value_int;
00259 dcsData >> value_int;
00260 sctDdcRequest->setfloatVecRequestResponse(dpeName, float(value_int));
00261 sctDdcRequest->setRequestReady_vec(true);
00262 break;
00263 case ISType::U32:
00264
00265 unsigned long value_uint;
00266 dcsData >> value_uint;
00267 sctDdcRequest->setfloatVecRequestResponse(dpeName, float(value_uint));
00268 sctDdcRequest->setRequestReady_vec(true);
00269 break;
00270 case ISType::Float:
00271
00272 float value_float;
00273 dcsData >> value_float;
00274 sctDdcRequest->setfloatVecRequestResponse(dpeName, value_float);
00275 sctDdcRequest->setRequestReady_vec(true);
00276 break;
00277 case ISType::Double:
00278
00279 double value_d;
00280 dcsData >> value_d;
00281 sctDdcRequest->setfloatVecRequestResponse(dpeName, float(value_d));
00282 sctDdcRequest->setRequestReady_vec(true);
00283 break;
00284 case ISType::String:
00285
00286 dcsData >> value_str;
00287 std::cerr
00288 <<"SCTDdcRequest::requestFloatVecCallback(..) DDC_ERROR: variable ("<<dpeName
00289 <<") is string, that is not supported in ddcRequest class"<< std::endl;
00290 break;
00291 case ISType::Date:
00292
00293 dcsData >> value_date;
00294 std::cerr
00295 <<"SCTDdcRequest::requestFloatVecCallback(..) DDC_ERROR: variable ("<<dpeName
00296 <<") is date, that is not supported in ddcRequest class"<< std::endl;
00297 break;
00298 case ISType::Time:
00299
00300 dcsData >> value_time;
00301
00302
00303 break;
00304
00305 default:
00306 cout << "SCTDdcRequest::requestCallback() DDC_ERROR: Invalid Type"
00307 << (long)dcsData.getAttributeType() << std::endl;
00308 }
00309 }
00310
00311 }
00312
00313
00314
00315 void SCTDdcRequest::ddcSendRequest(string& dpeName, int& value, int timeout)
00316
00317 {
00318
00319 ISInfo::Status rc;
00320
00321 string server_dpeName = m_requestServer + "." + dpeName;
00322
00323
00324 rc = m_infoReceiver->subscribe(server_dpeName.c_str(), requestCallback, (void*)this);
00325 if(rc != ISInfo::Success)
00326 {
00327 cerr << "SCTDdcRequest::ddcSendRequest() DDC_ERROR: " << server_dpeName
00328 << " subscription fault " << rc << ". No IS server to send request" << endl;
00329 }
00330
00331 time_t startRequestTime = time(&startRequestTime);
00332
00333
00334
00335 ISInfo::Status exportResult = ISInfo::Success;
00336 string isObName;
00337 time_t currTime;
00338
00339 isObName = m_requestServer + '.';
00340 isObName += DAQ_DATA_REQUEST;
00341
00342 DcsSingleData<string>* ddcRequestForData
00343 = new DcsSingleData<string>(time(&currTime), m_partition, (char*)isObName.c_str());
00344 ddcRequestForData->setValue(server_dpeName);
00345 exportResult = ddcRequestForData->checkin();
00346 if(exportResult == ISInfo::CommFailure)
00347 {
00348 cerr << "SCTDdcRequest::ddcSendRequest() DDC_ERROR: "
00349 << ctime((const time_t*)&currTime) << " IS server "
00350 << m_requestServer << " for DAQ's data requests in partition "
00351 << m_partition.name() << " does not run!" << endl;
00352 }
00353
00354
00355
00356
00357 int deltaRequestTime = 0;
00358 while(!m_requestReady && deltaRequestTime< timeout)
00359 {
00360 usleep(10);
00361 time_t timenow = time(&timenow);
00362 deltaRequestTime = timenow - startRequestTime;
00363 }
00364
00365 if(!m_requestReady)
00366 {
00367 cerr << "DDC_ERROR: request waiting time for "<<dpeName
00368 <<" is out!!, stupid value is returned!!"<<endl;
00369 m_infoReceiver->unsubscribe(server_dpeName.c_str());
00370 value = 9999999;
00371 delete ddcRequestForData;
00372 return;
00373 }
00374
00375
00376 value = m_intRequestResponse;
00377
00378 m_requestReady = false;
00379
00380
00381 ddcRequestForData->remove();
00382 delete ddcRequestForData;
00383 m_infoReceiver->unsubscribe(server_dpeName.c_str());
00384
00385
00386 return;
00387 }
00388
00389
00390
00391 void SCTDdcRequest::ddcSendRequest(string& dpeName, float* float_array, int& array_size, int timeout)
00392
00393 {
00394
00395 ISInfo::Status rc;
00396
00397 string server_dpeName = m_requestServer + "." + dpeName;
00398
00399
00400 rc = m_infoReceiver->subscribe(server_dpeName.c_str(),
00401 floatArrayRequestCallback, (void*)this);
00402 if(rc != ISInfo::Success)
00403 {
00404 cerr << "SCTDdcRequest::ddcSendRequest() DDC_ERROR: " << server_dpeName
00405 << " subscription fault " << rc << ". No IS server to send request" << endl;
00406 }
00407
00408 time_t startRequestTime = time(&startRequestTime);
00409
00410
00411
00412 ISInfo::Status exportResult = ISInfo::Success;
00413 string isObName;
00414 time_t currTime;
00415
00416 isObName = m_requestServer + '.';
00417 isObName += DAQ_DATA_REQUEST;
00418
00419 DcsSingleData<string>* ddcRequestForData
00420 = new DcsSingleData<string>(time(&currTime), m_partition, (char*)isObName.c_str());
00421 ddcRequestForData->setValue(server_dpeName);
00422 exportResult = ddcRequestForData->checkin();
00423 if(exportResult == ISInfo::CommFailure)
00424 {
00425 cerr << "SCTDdcRequest::ddcSendRequest() DDC_ERROR: "
00426 << ctime((const time_t*)&currTime) << " IS server "
00427 << m_requestServer << " for DAQ's data requests in partition "
00428 << m_partition.name() << " does not run!" << endl;
00429 }
00430
00431
00432
00433
00434 int deltaRequestTime = 0;
00435 while(!m_requestReady && deltaRequestTime< timeout)
00436 {
00437 usleep(10);
00438 time_t timenow = time(&timenow);
00439 deltaRequestTime = timenow - startRequestTime;
00440 }
00441
00442 if(!m_requestReady)
00443 {
00444 cerr << "DDC_ERROR: request waiting time for "<<dpeName
00445 <<" is out!!, stupid value is returned!!"<<endl;
00446 m_infoReceiver->unsubscribe(server_dpeName.c_str());
00447 float_array = NULL;
00448 delete ddcRequestForData;
00449 return;
00450 }
00451
00452
00453 array_size = m_floatArraySizeRequestResponse;
00454 for(int i=0; i<array_size; i++)
00455 {
00456 float_array[i] = m_floatArrayRequestResponse[i];
00457 }
00458
00459 m_requestReady = false;
00460
00461
00462 ddcRequestForData->remove();
00463 delete ddcRequestForData;
00464 m_infoReceiver->unsubscribe(server_dpeName.c_str());
00465
00466 return;
00467 }
00468
00469
00470
00471 void SCTDdcRequest::ddcSendRequest(string& dpeName, float& value, int timeout)
00472
00473 {
00474
00475 ISInfo::Status rc;
00476
00477 string server_dpeName = m_requestServer + "." + dpeName;
00478
00479
00480 rc = m_infoReceiver->subscribe(server_dpeName.c_str(), requestCallback, (void*)this);
00481 if(rc != ISInfo::Success)
00482 {
00483 cerr << "SCTDdcRequest::ddcSendRequest() DDC_ERROR: " << server_dpeName
00484 << " subscription fault " << rc << ". No IS server to send request" << endl;
00485 }
00486
00487 time_t startRequestTime = time(&startRequestTime);
00488
00489
00490
00491 ISInfo::Status exportResult = ISInfo::Success;
00492 string isObName;
00493 time_t currTime;
00494
00495 isObName = m_requestServer + '.';
00496 isObName += DAQ_DATA_REQUEST;
00497
00498 DcsSingleData<string>* ddcRequestForData
00499 = new DcsSingleData<string>(time(&currTime), m_partition, (char*)isObName.c_str());
00500 ddcRequestForData->setValue(server_dpeName);
00501 exportResult = ddcRequestForData->checkin();
00502 if(exportResult == ISInfo::CommFailure) {
00503 cerr << "SCTDdcRequest::ddcSendRequest() DDC_ERROR: " << ctime((const time_t*)&currTime)
00504 << " IS server "
00505 << m_requestServer << " for DAQ's data requests in partition "
00506 << m_partition.name() << " does not run!" << endl;
00507 }
00508
00509
00510
00511
00512 int deltaRequestTime = 0;
00513 while(!m_requestReady && deltaRequestTime< timeout)
00514 {
00515 usleep(10);
00516 time_t timenow = time(&timenow);
00517 deltaRequestTime = timenow - startRequestTime;
00518 }
00519
00520 if(!m_requestReady)
00521 {
00522 cerr << "SCTDdcRequest::ddcSendRequest() DDC_ERROR: request waiting time for "
00523 <<dpeName<<" is out!!"<<endl;
00524 m_infoReceiver->unsubscribe(server_dpeName.c_str());
00525 value = 9999999;
00526 delete ddcRequestForData;
00527 return;
00528 }
00529
00530
00531 value = m_floatRequestResponse;
00532
00533 m_requestReady = false;
00534
00535
00536 ddcRequestForData->remove();
00537 delete ddcRequestForData;
00538 m_infoReceiver->unsubscribe(server_dpeName.c_str());
00539
00540 return;
00541 }
00542
00543
00544
00545 void SCTDdcRequest::ddcSendRequest(string& dpeName, string& value, int timeout)
00546
00547 {
00548
00549 ISInfo::Status rc;
00550
00551 string server_dpeName = m_requestServer + "." + dpeName;
00552
00553
00554 rc = m_infoReceiver->subscribe(server_dpeName.c_str(), requestCallback, (void*)this);
00555 if(rc != ISInfo::Success)
00556 {
00557 cerr << "SCTDdcRequest::ddcSendRequest() DDC_ERROR: " << server_dpeName
00558 << " subscription fault " << rc << ". No IS server to send request" << endl;
00559 }
00560
00561 time_t startRequestTime = time(&startRequestTime);
00562
00563
00564
00565 ISInfo::Status exportResult = ISInfo::Success;
00566 string isObName;
00567 time_t currTime;
00568
00569 isObName = m_requestServer + '.';
00570 isObName += DAQ_DATA_REQUEST;
00571
00572 DcsSingleData<string>* ddcRequestForData
00573 = new DcsSingleData<string>(time(&currTime), m_partition, (char*)isObName.c_str());
00574 ddcRequestForData->setValue(server_dpeName);
00575 exportResult = ddcRequestForData->checkin();
00576 if(exportResult == ISInfo::CommFailure) {
00577 cerr << "SCTDdcRequest::ddcSendRequest() DDC_ERROR: "
00578 << ctime((const time_t*)&currTime) << " IS server "
00579 << m_requestServer << " for DAQ's data requests in partition "
00580 << m_partition.name() << " does not run!" << endl;
00581 }
00582
00583
00584
00585
00586 int deltaRequestTime = 0;
00587 while(!m_requestReady && deltaRequestTime< timeout)
00588 {
00589 usleep(10);
00590 time_t timenow = time(&timenow);
00591 deltaRequestTime = timenow - startRequestTime;
00592 }
00593
00594 if(!m_requestReady)
00595 {
00596 cerr << "SCTDdcRequest::ddcSendRequest() DDC_ERROR: request waiting time for "
00597 <<dpeName<<" is out!!"<<endl;
00598 m_infoReceiver->unsubscribe(server_dpeName.c_str());
00599 value = 9999999;
00600 delete ddcRequestForData;
00601 return;
00602 }
00603
00604
00605 value = m_stringRequestResponse;
00606
00607 m_requestReady = false;
00608
00609
00610 ddcRequestForData->remove();
00611 delete ddcRequestForData;
00612 m_infoReceiver->unsubscribe(server_dpeName.c_str());
00613
00614 return;
00615 }
00616
00617
00618
00619 void SCTDdcRequest::ddcSendRequest(std::vector<string>& dpeName_vec,
00620 std::map<string, float>& values_map, int timeout)
00621
00622 {
00623
00624 ISInfo::Status rc;
00625
00626 unsigned int numberOfRequest = dpeName_vec.size();
00627
00628 std::vector<string> server_dpeName;
00629
00630 for(unsigned int i_requ=0; i_requ<numberOfRequest; i_requ++)
00631 {
00632
00633 server_dpeName.push_back(m_requestServer + "." + dpeName_vec[i_requ]);
00634
00635 rc = m_infoReceiver->subscribe(server_dpeName[i_requ].c_str(), requestFloatVecCallback,
00636 (void*)this);
00637 if(rc != ISInfo::Success)
00638 {
00639 cerr << " SCTDdcRequest::ddcSendRequest() DDC_ERROR: " << server_dpeName[i_requ]
00640 << " subscription fault " << rc << ". No IS server to send request" << endl;
00641 }
00642 }
00643
00644
00645 requestReady_vec_init(numberOfRequest);
00646
00647 time_t startRequestTime = time(&startRequestTime);
00648
00649
00650
00651
00652 ISInfo::Status exportResult = ISInfo::Success;
00653 string isObName;
00654 time_t currTime;
00655
00656 isObName = m_requestServer + '.';
00657 isObName += DAQ_DATA_REQUEST;
00658
00659 DcsDataArray<string>* ddcRequestForData
00660 = new DcsDataArray<string>(time(&currTime), m_partition, (char*)isObName.c_str());
00661 for(unsigned int i_requ=0; i_requ<numberOfRequest; i_requ++)
00662 {
00663 ddcRequestForData->addValue(server_dpeName[i_requ]);
00664 }
00665
00666 exportResult = ddcRequestForData->checkin();
00667
00668 if(exportResult == ISInfo::CommFailure)
00669 {
00670 cerr << "SCTDdcRequest::ddcSendRequest() DDC_ERROR: " << ctime((const time_t*)&currTime)
00671 << " IS server "
00672 << m_requestServer << " for DAQ's data requests in partition "
00673 << m_partition.name() << " does not run!" << endl;
00674 }
00675
00676
00677
00678 int deltaRequestTime = 0;
00679 while(!getRequestReady_vec() && deltaRequestTime< timeout)
00680 {
00681 usleep(10);
00682 time_t timenow = time(&timenow);
00683 deltaRequestTime = timenow - startRequestTime;
00684 }
00685
00686
00687 if(!getRequestReady_vec())
00688 {
00689 cerr << "SCTDdcRequest::ddcSendRequest() DDC_ERROR: request waiting time for vector"
00690 <<" of float is out, or may be just some of the requests didn't come!!"<<endl;
00691 }
00692
00693
00694 values_map = m_floatVecRequestResponse;
00695
00696
00697 ddcRequestForData->remove();
00698 delete ddcRequestForData;
00699
00700
00701 for(unsigned int i_requ=0; i_requ<numberOfRequest; i_requ++)
00702 {
00703
00704 string server_dpeName = m_requestServer + "." + dpeName_vec[i_requ];
00705
00706 m_infoReceiver->unsubscribe(server_dpeName.c_str());
00707 }
00708
00709 return;
00710 }
00711
00712
00713 void getCallback(ISCallbackInfo* isCallback)
00714
00715 {
00716 OWLTime value_time;
00717
00718 float *value = (float*)(isCallback->parameter());
00719
00720
00721 ISInfoAny dcsData;
00722
00723 if(isCallback->reason() != ISInfoDeleted)
00724 {
00725 isCallback->value(dcsData);
00726 }
00727
00728
00729 int N = dcsData.countAttributes( );
00730
00731 for ( int i = 0; i < N; i++ )
00732 {
00733 switch ( dcsData.getAttributeType() )
00734 {
00735 case ISType::Float:
00736
00737 dcsData >> *value;
00738 break;
00739
00740 case ISType::Time:
00741
00742 dcsData >> value_time;
00743 break;
00744
00745 default:
00746 cout << " SCTDdcRequest::getCallback() ERROR: Invalid Type"
00747 << (long)dcsData.getAttributeType() << std::endl;
00748 }
00749 }
00750 return;
00751 }
00752
00753
00754 void SCTDdcRequest::readFromIS(string dpeName, float& value)
00755
00756 {
00757
00758 ISInfo::Status rc;
00759
00760 string server_dpeName = "DDC_DT." + dpeName;
00761
00762
00763 rc = m_infoReceiver->subscribe(server_dpeName.c_str(), getCallback, (void*)(&value));
00764 if(rc != ISInfo::Success)
00765 {
00766 cerr << "SCTDdcRequest::readFromIS() DDC_ERROR: " << server_dpeName
00767 << " subscription fault " << rc << ". No IS server to send request" << endl;
00768 }
00769 return;
00770 }
00771