00001
00020 #ifndef Manager_h
00021 #define Manager_h
00022
00023 #include <rtm/RTC.h>
00024
00025 #include <iostream>
00026 #include <string>
00027 #include <vector>
00028
00029 #include <ace/Synch.h>
00030 #include <ace/Task.h>
00031
00032 #include <rtm/Factory.h>
00033 #include <rtm/ECFactory.h>
00034 #include <rtm/ObjectManager.h>
00035 #include <rtm/RTObject.h>
00036 #include <rtm/SystemLogger.h>
00037
00038
00039
00040 namespace RTC
00041 {
00042 class Properties;
00043 class CorbaNaming;
00044 class ModuleManager;
00045 class NamingManager;
00046 class CorbaObjectManager;
00047 class Manager;
00048 class Timer;
00049
00050 typedef void (*ModuleInitProc)(Manager* manager);
00051
00072 class Manager
00073 {
00074 protected:
00088 Manager();
00089
00107 Manager(const Manager& manager);
00108
00109
00110 public:
00163 static Manager* init(int argc, char** argv);
00164
00187 static Manager& instance();
00188
00189
00190
00191
00192
00206 void terminate();
00207
00223 void shutdown();
00224
00238 void join();
00239
00257 Logbuf& getLogbuf() {return m_Logbuf;}
00258 MedLogbuf& getMedLogbuf() {return m_MedLogbuf;}
00259
00277 Properties& getConfig() { return m_config;}
00278
00303 void setModuleInitProc(ModuleInitProc proc);
00304
00337 bool activateManager();
00338
00369 void runManager(bool no_block = false);
00370
00371
00372
00373
00396 void load(const char* fname, const char* initfunc);
00397
00417 void unload(const char* fname);
00418
00434 void unloadAll();
00435
00453 std::vector<std::string> getLoadedModules();
00454
00474 std::vector<std::string> getLoadableModules();
00475
00476
00477
00478
00505 bool registerFactory(Properties& profile,
00506 RtcNewFunc new_func,
00507 RtcDeleteFunc delete_func);
00508
00535 bool registerECFactory(const char* name,
00536 ECNewFunc new_func,
00537 ECDeleteFunc delete_func);
00538
00556 std::vector<std::string> getModulesFactories();
00557
00558
00559
00560
00592 RtcBase* createComponent(const char* module_name);
00593
00612 void cleanupComponent(RtcBase* comp);
00613
00637 bool registerComponent(RtcBase* comp);
00638
00660 bool unregisterComponent(RtcBase* comp);
00661
00687 bool bindExecutionContext(RtcBase* comp);
00688
00713 void deleteComponent(const char* instance_name);
00714
00738 RtcBase* getComponent(const char* instance_name);
00739
00757 std::vector<RtcBase*> getComponents();
00758
00759
00760
00761
00779 CORBA::ORB_ptr getORB();
00780
00798 PortableServer::POA_ptr getPOA();
00799
00817 PortableServer::POAManager_ptr getPOAManager();
00818
00819
00820
00821
00822 protected:
00823
00824
00825
00826
00854 void initManager(int argc, char** argv);
00855
00871 void shutdownManager();
00872
00873
00874
00875
00897 bool initLogger();
00898
00916 void shutdownLogger();
00917
00918
00919
00920
00938 bool initORB();
00939
00959 std::string createORBOptions();
00960
00979 void shutdownORB();
00980
00981
00982
00983
01015 bool initNaming();
01016
01032 void shutdownNaming();
01033
01034
01035
01036
01052 void shutdownComponents();
01053
01076 void configureComponent(RtcBase* comp);
01077
01099 bool initExecContext();
01100
01120 bool initTimer();
01121
01147 bool mergeProperty(Properties& prop, const char* file_name);
01148
01197 std::string formatString(const char* naming_format,
01198 Properties& prop);
01199
01200
01201
01202
01203
01204
01205
01206
01214 static Manager* manager;
01215
01223 static ACE_Thread_Mutex mutex;
01224
01225
01226
01227
01235 CORBA::ORB_var m_pORB;
01236
01244 PortableServer::POA_var m_pPOA;
01245
01253 PortableServer::POAManager_var m_pPOAManager;
01254
01255
01256
01257
01265 ModuleInitProc m_initProc;
01266
01274 Properties m_config;
01275
01283 ModuleManager* m_module;
01284
01292 NamingManager* m_namingManager;
01293
01301 CorbaObjectManager* m_objManager;
01302
01310 Timer* m_timer;
01311
01312
01313
01314
01322 Logbuf m_Logbuf;
01323
01331 MedLogbuf m_MedLogbuf;
01332
01340 LogStream rtcout;
01341
01342
01343
01344
01345
01346 struct InstanceName
01347 {
01348 InstanceName(RtcBase* comp) : m_name(comp->getInstanceName()) {};
01349 InstanceName(const char* name) : m_name(name) {};
01350 InstanceName(const std::string name) : m_name(name) {};
01351 bool operator()(RtcBase* comp)
01352 {
01353 return m_name == comp->getInstanceName();
01354 }
01355 std::string m_name;
01356 };
01357
01358 typedef ObjectManager<std::string, RtcBase, InstanceName> ComponentManager;
01359
01367 ComponentManager m_compManager;
01368
01369
01370
01371
01372
01373 struct FactoryPredicate
01374 {
01375 FactoryPredicate(const char* name) : m_name(name){};
01376 FactoryPredicate(FactoryBase* factory)
01377 : m_name(factory->profile()["implementation_id"]) {};
01378 bool operator()(FactoryBase* factory)
01379 {
01380 return m_name == factory->profile()["implementation_id"];
01381 }
01382 std::string m_name;
01383 };
01384
01392 typedef ObjectManager<const char*, FactoryBase,
01393 FactoryPredicate> FactoryManager;
01394
01402 FactoryManager m_factory;
01403
01404
01405
01406
01407
01408 struct ECFactoryPredicate
01409 {
01410 ECFactoryPredicate(const char* name) : m_name(name){};
01411 ECFactoryPredicate(ECFactoryBase* factory)
01412 : m_name(factory->name()) {};
01413 bool operator()(ECFactoryBase* factory)
01414 {
01415 return m_name == factory->name();
01416 }
01417 std::string m_name;
01418 };
01419 typedef ObjectManager<const char*,
01420 ECFactoryBase,
01421 ECFactoryPredicate> ECFactoryManager;
01422
01430 ECFactoryManager m_ecfactory;
01431
01439 std::vector<ExecutionContextBase*> m_ecs;
01440
01441
01442 struct ModuleFactories
01443 {
01444 void operator()(FactoryBase* f)
01445 {
01446 modlist.push_back(f->profile().getProperty("implementation_id"));
01447 }
01448 std::vector<std::string> modlist;
01449 };
01450
01451
01452
01453
01473 class OrbRunner
01474 : public ACE_Task<ACE_MT_SYNCH>
01475 {
01476 public:
01490 OrbRunner(CORBA::ORB_ptr orb) : m_pORB(orb)
01491 {
01492 open(0);
01493 };
01494
01516 virtual int open(void *args)
01517 {
01518 activate();
01519 return 0;
01520 }
01521
01539 virtual int svc(void)
01540 {
01541 m_pORB->run();
01542 Manager::instance().shutdown();
01543 return 0;
01544 }
01545
01567 virtual int close(unsigned long flags)
01568 {
01569 return 0;
01570 }
01571 private:
01572 CORBA::ORB_ptr m_pORB;
01573 };
01574 OrbRunner* m_runner;
01575
01576
01577
01578
01598 class Terminator
01599 : public ACE_Task<ACE_MT_SYNCH>
01600 {
01601 public:
01619 Terminator(Manager* manager) : m_manager(manager) {};
01620
01634 void terminate()
01635 {
01636 open(0);
01637 }
01638
01660 virtual int open(void *args)
01661 {
01662 activate();
01663 return 0;
01664 }
01665
01683 virtual int svc(void)
01684 {
01685 Manager::instance().shutdown();
01686 return 0;
01687 }
01688 Manager* m_manager;
01689 };
01690
01698 Terminator* m_terminator;
01699
01700 struct Term
01701 {
01702 int waiting;
01703 ACE_Thread_Mutex mutex;
01704 };
01705 Term m_terminate;
01706 };
01707 };
01708
01709 #endif // Manager_h