BOSS 8.0.0
BESIII Offline Software System
Loading...
Searching...
No Matches
efpsc::SC Class Reference

#include <SC.h>

Inheritance diagram for efpsc::SC:

Public Member Functions

 SC ()
virtual ~SC ()
virtual bool configure (const std::string &config)
virtual bool unconfigure (void)
virtual bool prepareForRun (int run_number)
virtual bool process (const uint32_t *&feStore, const uint32_t *&sdStore, std::string &efDecision_s, std::vector< uint32_t > &efBitPattern)
Public Member Functions inherited from efhlt::Interface
virtual ~Interface ()

Detailed Description

Definition at line 24 of file SC.h.

Constructor & Destructor Documentation

◆ SC()

efpsc::SC::SC ( )

C'tor. (Nothing happens here...)

Definition at line 34 of file SC.cxx.

35 : m_eventLoopMgr( 0 )
36 , m_config( 0 )
37 , m_pesaAppMgr( 0 )
38 , m_isCreated( false )
39 , m_outLev( 5 )
40 , m_nameEventLoopMgr( "EFEventLoopMgr" ) {
41 ::setenv( "SCOutputLevel", "3", 1 );
42 char* ss = ::getenv( "SCOutputLevel" );
43 // if(ss!=NULL)std::cout<<ss<<std::endl;
44 // else std::cout<<"****************"<<std::endl;
45 // char* outlev=::getenv("SCOutputLevel");
46 // std::cout<<outlev<<std::endl;
47 // m_outLev=atoi(outlev);
48 // std::cout<<m_outLev<<std::endl;
49 // Hlt::MyFrame::instance();
50}

◆ ~SC()

efpsc::SC::~SC ( )
virtual

D'tor virtualisation

Definition at line 52 of file SC.cxx.

52 {
53 // delete Hlt::MyFrame::instance();
54 m_pesaAppMgr->release();
55}

Member Function Documentation

◆ configure()

bool efpsc::SC::configure ( const std::string & config)
virtual

Configures the framework

Parameters
configIs the only configuration parameter passed. The actual configuration implementation has to parse it, if that is the case in order to find its own way through the framework's configuration system.

Implements efhlt::Interface.

Definition at line 57 of file SC.cxx.

57 {
58 static bool first_call_configure = true;
59 if ( first_call_configure ) { first_call_configure = false; }
60 else { return true; }
61 // if(0==Hlt::MyFrame::instance()){
62 // std::cout<<"Error while create MyFrame"<<std::endl;
63 // exit(1);
64 //}
65
66 // EFPSC_DBG1("efpsc::SC::configure",
67 // "SC configuration started.");
68 if ( m_outLev <= 3 )
69 std::cout << "efpsc::SC::configure "
70 << "SC configuration started." << std::endl;
71 m_config = new efpsc::Config( config );
72
73 // Create an instance of the Pesa application manager
74 // EFPSC_DBG1("efpsc::SC::configure",
75 // "---> Create Pesa Application Manager");
76 if ( m_outLev <= 2 )
77 std::cout << "efpsc::SC::configure "
78 << "---> Create Pesa Application Manager:" << m_isCreated << std::endl;
79 if ( !m_isCreated )
80 {
81 if ( ( m_config->dllName().size() != 0 ) && ( m_config->factoryName().size() != 0 ) )
82 {
83 m_pesaAppMgr =
84 Gaudi::createApplicationMgr( m_config->dllName(), m_config->factoryName() );
85 if ( m_outLev <= 3 )
86 std::cout << "Gaudi::createApplicationMgr(m_config->dllName(),m_config->factoryName())"
87 << std::endl;
88 }
89 else
90 {
91 m_pesaAppMgr = Gaudi::createApplicationMgr();
92 if ( m_outLev <= 3 ) std::cout << "Gaudi::createApplicationMgr()" << std::endl;
93 }
94 }
95
96 // configure Pesa
97 // EFPSC_DBG1("efpsc::SC::configure",
98 // "---> Configure Pesa Property Manager");
99 if ( m_outLev <= 2 )
100 std::cout << "efpsc::SC::configure "
101 << "---> Configure Pesa Property Manager" << std::endl;
102 StatusCode sc;
103 SmartIF<IProperty> propMgr( m_pesaAppMgr );
104 SmartIF<IAppMgrUI> appMgr( m_pesaAppMgr );
105 if ( !appMgr.isValid() || !propMgr.isValid() )
106 {
107 // EFPSC_ERROR("efpsc::SC::configure",
108 // "While creating the ApplicationMgr");
109 if ( m_outLev <= 5 )
110 std::cout << "efpsc::SC::configure "
111 << "While creating the ApplicationMgr" << std::endl;
112 return false;
113 }
114
115 // Get the input configuration file from arguments (default "jobOptions.txt")
116 std::string opts = "jobOptions.txt";
117 ::setenv( "efJobPath", "", 1 );
118 if ( m_config->jobOptionsPath().size() != 0 )
119 {
120 opts = m_config->jobOptionsPath();
121 if ( opts.rfind( "/" ) < opts.size() )
122 { ::setenv( "efJobPath", opts.substr( 0, opts.rfind( "/" ) ).c_str(), 1 ); }
123 }
124 // EFPSC_DBG1("efpsc::SC::configure", "---> Pesa JobOptions file is = " << opts);
125 // EFPSC_DBG1("efpsc::SC::configure", "---> Pesa JobOptions path = " <<
126 // ::getenv("efJobPath"));
127 if ( m_outLev <= 2 )
128 std::cout << "efpsc::SC::configure "
129 << "---> Pesa JobOptions file is = " << opts << std::endl
130 << " "
131 << "---> Pesa JobOptions path = " << ::getenv( "efJobPath" ) << std::endl;
132 propMgr->setProperty( "JobOptionsPath", opts );
133
134 propMgr->setProperty( "EventLoop", m_nameEventLoopMgr );
135
136 // Select the MessageSvc Type
137 if ( m_config->messageSvcType().size() != 0 )
138 { propMgr->setProperty( "MessageSvcType", m_config->messageSvcType() ); }
139
140 // No EventSelector will be used
141 if ( m_config->evtSel().size() != 0 )
142 { propMgr->setProperty( "EvtSel", m_config->evtSel() ); }
143 else { propMgr->setProperty( "EvtSel", "NONE" ); }
144 // EFPSC_DBG1("efpsc::SC::configure", "finish property set--->start configure ");
145 // EFPSC_DBG1("efpsc::SC::configure", "Configuring ApplicationMgr: "
146 // << appMgr->stateName() << " Status : " << sc.getCode());
147 if ( m_outLev <= 3 )
148 std::cout << "efpsc::SC::configure "
149 << "finish property set--->start configure" << std::endl;
150 if ( m_outLev <= 2 )
151 std::cout << "efpsc::SC::configure "
152 << "Configuring ApplicationMgr: " << appMgr->FSMState()
153 << " Status : " << sc.getCode() << std::endl;
154 // Configure the application manager
155 if ( opts.substr( opts.length() - 3, 3 ) == ".py" )
156 {
157
158 // EFPSC_ERROR("efpsc::SC::configure",
159 // "Error: Don't support python config files");
160 if ( m_outLev <= 5 )
161 std::cout << "efpsc::SC::configure "
162 << "Error: Don't support python config files" << std::endl;
163 return false;
164 // ----------------------------
165 // Configuration with .py files
166 // ----------------------------
167
168 // Try to initialize the Python interpreter
169 /*if ( ! Py_IsInitialized() ) {
170 Py_Initialize();
171
172 // check
173 if ( ! Py_IsInitialized() ) {
174 EFPSC_ERROR("efpsc::SC::configure",
175 "Error: Python could not been intialized.");
176 Py_Finalize();
177 return false;
178 }
179
180 // import basic python modules (used throughout)
181 std::string pyBasicFile = "SC/SCPythonSetup.py" ;
182 if (m_config->pythonSetupFile().size() != 0) {
183 pyBasicFile = m_config->pythonSetupFile() ;
184 }
185
186 pyBasicFile = PathResolver::find_file(pyBasicFile, "PYTHONPATH");
187 FILE* infile = fopen( pyBasicFile.c_str() , "r" );
188 if ( PyRun_SimpleFile(infile,const_cast<char*>(pyBasicFile.c_str())) != 0 ) {
189 EFPSC_ERROR("efpsc::SC::configure",
190 "Error: Basic Python configuration failed.");
191 Py_Finalize();
192 return false;
193 }
194
195 std::string pyExecFile = "include( \""+std::string(opts)+"\" )" ;
196 if ( PyRun_SimpleString(const_cast<char*>(pyExecFile.c_str())) != 0 ) {
197 EFPSC_ERROR("efpsc::SC::configure",
198 "Error: Python job configuration script failed.");
199 Py_Finalize();
200 return false;
201 }
202 }*/
203 }
204 else
205 {
206 // -----------------------------
207 // Configuration with .txt files
208 // -----------------------------
209 sc = appMgr->configure();
210 if ( sc.isFailure() )
211 {
212 // EFPSC_DBG1("efpsc::SC::configure",
213 // "While configuring the ApplicationMgr");
214 if ( m_outLev <= 5 )
215 std::cout << "efpsc::SC::configure "
216 << "While configuring the ApplicationMgr" << std::endl;
217 return false;
218 }
219 }
220 // EFPSC_DBG1("efpsc::SC::configure", "Configuring ApplicationMgr: "
221 // << appMgr->stateName() << " Status : " << sc.getCode());
222 if ( m_outLev <= 2 )
223 std::cout << "efpsc::SC::configure "
224 << "Configuring ApplicationMgr: " << appMgr->FSMState()
225 << " Status : " << sc.getCode() << std::endl;
226 // Initialize the application manager
227 sc = appMgr->initialize();
228 // EFPSC_DBG1("efpsc::SC::configure", "Initialize ApplicationMgr : "
229 // << appMgr->stateName()
230 // << " Status : " << sc.getCode());
231 if ( m_outLev <= 2 )
232 std::cout << "efpsc::SC::configure "
233 << "Initialize ApplicationMgr : " << appMgr->FSMState()
234 << " Status : " << sc.getCode() << std::endl;
235 if ( sc.isFailure() )
236 {
237 EFPSC_ERROR( "efpsc::SC::configure", "While intializing the ApplicationMgr" );
238 return false;
239 }
240
241 // Find the basename for the EventLoopMgr
242 std::string value;
243 // std::cout<<"value = "<<value<<std::endl;
244 sc = propMgr->getProperty( "EventLoop", value );
245 // std::cout<<"value = "<<value<<std::endl;
246 if ( sc.isFailure() )
247 {
248 // EFPSC_DBG1("efpsc::SC::configure", "While retrieving Property EventLoop ");
249 if ( m_outLev <= 4 )
250 std::cout << "efpsc::SC::configure "
251 << "While retrieving Property EventLoop " << std::endl;
252 }
253 else
254 {
255 m_nameEventLoopMgr.assign( value, value.find_first_of( "\"" ) + 1,
256 value.find_last_of( "\"" ) - value.find_first_of( "\"" ) - 1 );
257 }
258
259 SmartIF<ISvcLocator> svcLoc( m_pesaAppMgr );
260 if ( svcLoc.isValid() )
261 {
262 // EFPSC_DBG1("efpsc::SC::configure","Name for EventLoopManager:"<<m_nameEventLoopMgr);
263 if ( m_outLev <= 2 )
264 std::cout << "efpsc::SC::configure "
265 << "Name for EventLoopManager:" << m_nameEventLoopMgr << std::endl;
266 StatusCode sc;
267 IEventProcessor* processingMgr = 0;
268
269 sc = svcLoc->service( m_nameEventLoopMgr, processingMgr );
270 m_eventLoopMgr = processingMgr;
271
272 if ( !sc.isSuccess() )
273 {
274 // EFPSC_ERROR("efpsc::SC::configure", " Error Retrieving Processing manager!") ;
275 if ( m_outLev <= 5 )
276 std::cout << "efpsc::SC::configure "
277 << "Error Retrieving Processing manager!" << std::endl;
278 return false;
279 }
280 }
281 else
282 {
283 // EFPSC_ERROR("efpsc::SC::configure", " Error Retrieving Service Locator!") ;
284 if ( m_outLev <= 5 )
285 std::cout << "efpsc::SC::configure "
286 << "Error Retrieving Service Locator!" << std::endl;
287 return false;
288 }
289
290 m_isCreated = true;
291 // EFPSC_DBG1("efpsc::SC::configure","SC configuration finished.");
292 if ( m_outLev <= 3 )
293 std::cout << "efpsc::SC::configure "
294 << "SC configuration finished." << std::endl;
295 return true;
296}

◆ prepareForRun()

bool efpsc::SC::prepareForRun ( int run_number)
virtual

prepares the HLT framework for a run

Parameters
run_numberThe Run number to be used for this run.

Implements efhlt::Interface.

Definition at line 389 of file SC.cxx.

389 {
390 // This is a placeholder method
391 if ( m_eventLoopMgr )
392 {
393 SmartIF<IEFEventLoopMgr> processor_psc( m_eventLoopMgr );
394 StatusCode sc = processor_psc->prepareForRun( run_number );
395 std::cout << "=================" << m_eventLoopMgr << std::endl;
396 if ( sc.isSuccess() ) return true;
397 }
398 return false;
399}

◆ process()

bool efpsc::SC::process ( const uint32_t *& feStore,
const uint32_t *& sdStore,
std::string & efDecision_s,
std::vector< uint32_t > & efBitPattern )
virtual

Process one event, taking as input a pointer to the RawEvent serialized in a contiguous memory region (feStore) and giving as output the yes/no decision and the address (sdStore) of the "local" memory region containing the serialized EF fragment

Implements efhlt::Interface.

Definition at line 401 of file SC.cxx.

402 {
403 // std::cout<<"jak:"<<__FILE__<<std::endl;
404 // EFPSC_DBG1("efpsc::SC::process", "***********************************************");
405 // EFPSC_DBG1("efpsc::SC::process", "****************** NEW EVENT ******************");
406 // EFPSC_DBG1("efpsc::SC::process", "***********************************************");
407 if ( m_outLev <= 3 )
408 std::cout << "efpsc::SC::process"
409 << " **************** NEW EVENT ****************" << std::endl;
410 // Test if FullEventFragment is valid
411 // if(!fe->is_valid()){
412 // EFPSC_ERROR("efpsc::SC::process","FullEventFragment NOT valid! This event is not going
413 // to be processed!"); return false;
414 // } else {
415 // EFPSC_DBG1("efpsc::SC::process", " FullEventFragment is valid." );
416 // }
417
418 // ExecuteEvent from the application manager
419 StatusCode sc;
420 if ( 0 != m_eventLoopMgr )
421 {
422 SmartIF<IEventProcessor> processor( m_eventLoopMgr );
423
424 if ( processor.isValid() )
425 {
426 SmartIF<IService> processor_s( m_eventLoopMgr );
427 // EFPSC_DBG1("efpsc::SC::process", " ---> Executing events for
428 // processor"<<processor_s->name()); std::cout<<"jak:"<<__FILE__<<std::endl;
429
430 sc = processor->executeEvent( (void*)feStore );
431
432 // EFPSC_DBG1("efpsc::SC::Process","after executeEvent(fe)");
433
434 // std::cout<<"jak:"<<__FILE__<<std::endl;
435 if ( m_outLev <= 2 )
436 std::cout << "efpsc::SC::process "
437 << "after executeEvent(fe)" << std::endl;
438 if ( sc.isFailure() )
439 {
440 // EFPSC_DBG1("efpsc::SC::process", "Error for executeEvent in the ApplicationMgr " <<
441 // processor_s->name());
442 if ( m_outLev <= 4 )
443 std::cout << "efpsc::SC::process "
444 << "Error for executeEvent in the ApplicationMgr " << processor_s->name()
445 << std::endl;
446 }
447 else
448 {
449 SmartIF<IEFEventLoopMgr> processor_psc( m_eventLoopMgr );
450 //
451 //--- ef Decision and Result from Pesa
452 //
453 // std::cout<<"jak:"<<__FILE__<<std::endl;
454 efDecision_s = processor_psc->EF_Decision();
455
456 // std::cout<<"jak:"<<__FILE__<<std::endl;
457 // EFPSC_DBG1("efpsc::SC::Process","after EF_Decision. EFdecision is: "<<efDecision_s);
458 if ( m_outLev <= 3 )
459 std::cout << "efpsc::SC::process "
460 << "after EF_Decision. EFdecision is: " << efDecision_s << std::endl;
461 sdStore = (uint32_t*)processor_psc->EF_Fragment_Address();
462 // std::cout<<"jak:"<<__FILE__<<std::endl;
463 if ( sdStore == NULL )
464 {
465 // EFPSC_DBG1("efpsc::SC::process","EF_Fragment_Address() returns NULL pointer");
466 if ( m_outLev <= 2 )
467 std::cout << "efpsc::SC::process "
468 << "EF_Fragment_Address() returns NULL pointer" << std::endl;
469 }
470 // Hard coded (One must change it in the future):
471 // EF_Decision==Accepted--> efDecision=2
472 // EF_Decision==Rejected--> efDecision=1
473 // EF_Decision==Error--> efDecision=0
474 /*
475 if(efDecision_s=="Accepted"){
476 //efDecision=2;
477 //Append EFResult to the Event Fragment
478 EFPSC_DBG1("efpsc::SC::process", "EFResult is going to be appended to the Event
479 Fragment"); }else if(efDecision_s=="Rejected"){
480 //efDecision=1;
481 EFPSC_DBG1("efpsc::SC::process", "No EFResult is going to be appended to the Event
482 Fragment");
483
484 }else{
485 //efDecision=0;
486 EFPSC_DBG1("efpsc::SC::process", "an Error was obtained when running algorithms on
487 the Event."); EFPSC_DBG1("efpsc::SC::process", "No EFResult is going to be appended to
488 the Event Fragment");
489 }
490 */
491 efBitPattern.resize( 4, 0 ); // zoujh: Just a place holder
492 if ( efDecision_s == "Junk" ) efBitPattern[0] = 1 << 0;
493 // else if(efDecision_s=="GJunk") efBitPattern[0]=(1<<0)+(1<<1);
494 else if ( efDecision_s == "GJunk" ) efBitPattern[0] = ( 1 << 1 );
495 else if ( efDecision_s == "Beamgas" ) efBitPattern[0] = 1 << 2;
496 // else if(efDecision_s=="GBeamgas") efBitPattern[0]=(1<<2)+(1<<3);
497 else if ( efDecision_s == "GBeamgas" ) efBitPattern[0] = ( 1 << 3 );
498 else if ( efDecision_s == "Cosmic" ) efBitPattern[0] = 1 << 4;
499 // else if(efDecision_s=="GCosmic") efBitPattern[0]=(1<<4)+(1<<5);
500 else if ( efDecision_s == "GCosmic" ) efBitPattern[0] = ( 1 << 5 );
501 else if ( efDecision_s == "EBhabha" ) efBitPattern[0] = 1 << 6;
502 // else if(efDecision_s=="GEBhabha") efBitPattern[0]=(1<<6)+(1<<7);
503 else if ( efDecision_s == "GEBhabha" ) efBitPattern[0] = ( 1 << 7 );
504 else if ( efDecision_s == "BBhabha" ) efBitPattern[0] = 1 << 8;
505 // else if(efDecision_s=="GBBhabha") efBitPattern[0]=(1<<8)+(1<<9);
506 else if ( efDecision_s == "GBBhabha" ) efBitPattern[0] = ( 1 << 9 );
507 else if ( efDecision_s == "Dimuon" ) efBitPattern[0] = 1 << 10;
508 // else if(efDecision_s=="GDimuon") efBitPattern[0]=(1<<10)+(1<<11);
509 else if ( efDecision_s == "GDimuon" ) efBitPattern[0] = ( 1 << 11 );
510 else if ( efDecision_s == "Diphoton" ) efBitPattern[0] = 1 << 12;
511 // else if(efDecision_s=="GDiphoton") efBitPattern[0]=(1<<12)+(1<<13);
512 else if ( efDecision_s == "GDiphoton" ) efBitPattern[0] = ( 1 << 13 );
513 else if ( efDecision_s == "Hadron" ) efBitPattern[0] = 1 << 14;
514 // else if(efDecision_s=="GHadron") efBitPattern[0]=(1<<14)+(1<<15);
515 else if ( efDecision_s == "GHadron" ) efBitPattern[0] = ( 1 << 15 );
516 else if ( efDecision_s == "Twophoton" ) efBitPattern[0] = 1 << 16;
517 // else if(efDecision_s=="GTwophoton") efBitPattern[0]=(1<<16)+(1<<17);
518 else if ( efDecision_s == "GTwophoton" ) efBitPattern[0] = ( 17 );
519 else if ( efDecision_s == "RandomTrg" ) efBitPattern[0] = 1 << 31;
520 else if ( efDecision_s == "Error" ) efBitPattern[0] = 1 << 30;
521 else if ( efDecision_s == "Other" ) efBitPattern[0] = 1 << 29;
522 else efBitPattern[0] = 1 << 28;
523 efBitPattern[1] = processor_psc->EF_Algorithm_Tag();
524 efBitPattern[2] = processor_psc->EF_Version();
525 efBitPattern[3] = processor_psc->EF_Total_Energy();
526 // EFPSC_DBG1("efpsc::SC::process", "**************end of psc
527 // process!**************"<<std::endl);
528 if ( m_outLev <= 2 )
529 std::cout << "efpsc::SC::process "
530 << "**************end of psc process!**************" << std::endl;
531 }
532 }
533 else
534 {
535 // EFPSC_DBG1("efpsc::SC::process", "executeEvent ApplicationMgr : no valid event
536 // processor ");
537 if ( m_outLev <= 5 )
538 std::cout << "efpsc::SC::process "
539 << "executeEvent ApplicationMgr : no valid event processor " << std::endl;
540 return false;
541 }
542 }
543 else { return false; }
544 return true;
545}

◆ unconfigure()

bool efpsc::SC::unconfigure ( void )
virtual

Unconfigures the framework, releasing all acquired resources.

Implements efhlt::Interface.

Definition at line 298 of file SC.cxx.

298 {
299 return true;
300 // EFPSC_DBG1("efpsc::SC::unconfigure",
301 // "SC UNconfiguration started.");
302 if ( m_outLev <= 3 )
303 std::cout << "efpsc::SC::unconfigure "
304 << "SC UNconfiguration started." << std::endl;
305 StatusCode sc;
306 SmartIF<IAppMgrUI> appMgr( m_pesaAppMgr );
307 if ( !appMgr.isValid() )
308 {
309 // EFPSC_ERROR("efpsc::SC::unconfigure",
310 // "While unconfiguring the ApplicationMgr, no valid interface");
311 if ( m_outLev <= 5 )
312 std::cout << "efpsc::SC::unconfigure "
313 << "While unconfiguring the ApplicationMgr, no valid interface" << std::endl;
314 return false;
315 }
316 SmartIF<ISvcLocator> svcLoc( m_pesaAppMgr );
317
318 // const std::list<IService*>* svclist=svcLoc->getServices();
319 // for(std::list<IService*>::iterator it = svclist->begin(); it != svclist->end(); it++ ) {
320 // std::cout<<(*it)->name()<<std::endl;
321 // }
322
323 // Finalize the application manager
324 sc = appMgr->finalize();
325
326 // EFPSC_DBG1("efpsc::SC::unconfigure", "Finalize ApplicationMgr: "
327 // << appMgr->stateName() << " Status : " << sc.getCode());
328 if ( m_outLev <= 2 )
329 std::cout << "efpsc::SC::unconfigure "
330 << "Finalize ApplicationMgr: " << appMgr->FSMState()
331 << " Status : " << sc.getCode() << std::endl;
332 if ( sc.isFailure() )
333 {
334 // EFPSC_ERROR("efpsc::SC::unconfigure",
335 // "---> While finalizing the ApplicationMgr ");
336 if ( m_outLev <= 5 )
337 std::cout << "efpsc::SC::unconfigure "
338 << "While finalizing the ApplicationMgr" << std::endl;
339 return false;
340 }
341
342 // Terminate the application manager
343 sc = appMgr->terminate();
344 // EFPSC_DBG1("efpsc::SC::unconfigure", "Terminate ApplicationMgr : "
345 // << appMgr->stateName() << " Status : " << sc.getCode());
346 if ( m_outLev <= 2 )
347 std::cout << "efpsc::SC::unconfigure "
348 << "Terminate ApplicationMgr : " << appMgr->FSMState()
349 << " Status : " << sc.getCode() << std::endl;
350 if ( sc.isFailure() )
351 {
352 // EFPSC_ERROR("efpsc::SC::unconfigure","While terminating the ApplicationMgr");
353 if ( m_outLev <= 5 )
354 std::cout << "efpsc::SC::unconfigure "
355 << "While terminating the ApplicationMgr" << std::endl;
356 return false;
357 }
358
359 // IService* msgSvc=0;
360 // svclist=svcLoc->getServices();
361 // svclist->erase(svclist.begin(), svclist.end() );
362 // std::cout<<svclist->size()<<std::endl;
363 // if(svcLoc->existsService("MessageSvc")){
364 // svcLoc->getService("MessageSvc",msgSvc);
365 // std::cout<<"111"<<msgSvc->name()<<std::endl;
366 // std::list<IService*> svclist=svcLoc->getServices();
367 // for(std::list<IService*>::iterator it = svclist.begin(); it != svclist.end(); it++ )
368 // {
369 // //std::cout<<(*it)->name()<<std::endl;
370 // }
371 // int a1=svclist.size();
372 // svclist->remove(msgSvc);
373 // int a2=svclist.size();
374 // if(svcLoc->existsService("MessageSvc"))std::cout<<"exist"<<a1<<","<<a2<<std::endl;
375 // }
376 // appMgr->release();
377 // if(msgSvc) msgSvc->release();
378 // svcMgr->removeService("MessageSvc");
379
380 delete m_config;
381 m_config = 0;
382 // EFPSC_DBG2("efpsc::SC::unconfigure", "SC UNconfiguration finished.");
383 if ( m_outLev <= 3 )
384 std::cout << "efpsc::SC::unconfigure "
385 << "SC UNconfiguration finished." << std::endl;
386 return true;
387}
The documentation for this class was generated from the following files: