Blinker

1) /* Blinker
2)    Copyright 2011 Stefan Schuermans <stefan@blinkenarea.org>
3)    Copyleft GNU public license - http://www.gnu.org/copyleft/gpl.html
4)    a blinkenarea.org project */
5) 
6) #ifndef MODULEMGR_H
7) #define MODULEMGR_H
8) 
9) #include <list>
10) 
11) #include "CallMgr.h"
12) #include "Directory.h"
13) #include "Module.h"
14) #include "StreamMgr.h"

15) #include "TimeCallee.h"

16) 
17) namespace Blinker {
18) 
19) /// manager for modules of one type
20) template<typename MODULE>

21) class ModuleMgr: public TimeCallee

22) {
23) protected:
24)   /// module list entry
25)   struct Entry {
26)     std::string m_name;     ///< name of module
27)     MODULE      *m_pModule; ///< module object
28)     Entry(const std::string &name); ///< constructor
29)     void createModule(ModuleMgr &mgr); ///< create module
30)     void destroyModule(); ///< destroy module
31)   };
32) 
33)   /// module list
34)   typedef std::list<Entry> ModuleList;
35) 
36) public:
37)   /**
38)    * @brief constructor
39)    * @param[in] callMgr callback manager
40)    * @param[in] streamMgr stream manager
41)    * @param[in] dirBase base directory
42)    */
43)   ModuleMgr(CallMgr &callMgr, StreamMgr &streamMgr, const Directory &dirBase);
44) 
45)   /// destructor
46)   ~ModuleMgr();
47) 
48) private:
49)   /// copy constructor disabled

50)   ModuleMgr(const ModuleMgr &that);

51) 
52)   /// assignment operator disabled
53)   const ModuleMgr & operator=(const ModuleMgr &that);
54) 
55) public:

56)   /// callback when requsted time reached
57)   virtual void timeCall();
58) 
59) protected:

60)   /// check for update of configuration
61)   void updateConfig();
62) 

63)   /// light update of module list, i.e. call all modules in current list
64)   void updateModuleListLight();
65) 
66)   /// full update of module list, i.e. scan all subdirs in base directory
67)   void updateModuleListFull();

68) 
69) protected:
70)   CallMgr     &m_callMgr;   ///< callback manager
71)   StreamMgr   &m_streamMgr; ///< stream manager
72)   Directory   m_dirBase;    ///< base directory
73)   ModuleList  m_moduleList; ///< module list
74) }; // class ModuleMgr
75) 
76) /* #############
77)    # ModuleMgr #
78)    ############# */
79) 
80) /**
81)  * @brief constructor
82)  * @param[in] callMgr callback manager
83)  * @param[in] streamMgr stream manager
84)  * @param[in] dirBase base directory
85)  */
86) template<typename MODULE>
87) ModuleMgr<MODULE>::ModuleMgr(CallMgr &callMgr, StreamMgr &streamMgr,
88)                              const Directory &dirBase):
89)   m_callMgr(callMgr),
90)   m_streamMgr(streamMgr),
91)   m_dirBase(dirBase)
92) {

93)   updateModuleListFull();
94) 
95)   // request call in 1s
96)   m_callMgr.requestTimeCall(this, Time::now() + Time(1));

97) }
98) 
99) /// destructor
100) template<typename MODULE>
101) ModuleMgr<MODULE>::~ModuleMgr()
102) {
103)   // free all modules
104)   while (!m_moduleList.empty()) {
105)     m_moduleList.back().destroyModule();
106)     m_moduleList.pop_back();
107)   }
108) }
109) 

110) /// callback when requsted time reached
111) template<typename MODULE>
112) void ModuleMgr<MODULE>::timeCall()
113) {
114)   updateConfig();
115) 
116)   // request next call in 1s
117)   m_callMgr.requestTimeCall(this, Time::now() + Time(1));
118) }
119) 

120) /// check for update of configuration
121) template<typename MODULE>
122) void ModuleMgr<MODULE>::updateConfig()
123) {

124)   // module list update (base directory modified -> full, otherwise -> light)

125)   if (m_dirBase.checkModified())

126)     updateModuleListFull();
127)   else
128)     updateModuleListLight();
129) }
130) 
131) /// light update of module list, i.e. call all modules in current list
132) template<typename MODULE>
133) void ModuleMgr<MODULE>::updateModuleListLight()
134) {
135)   typename ModuleList::iterator itEntry;
136)   for (itEntry = m_moduleList.begin(); itEntry != m_moduleList.end();
137)        ++itEntry) {
138) 
139)     // call module to check for changes
140)     itEntry->m_pModule->updateConfig();
141) 
142)   } // for itEntry

143) }
144) 

145) /// full update of module list, i.e. scan all subdirs in base directory

146) template<typename MODULE>

147) void ModuleMgr<MODULE>::updateModuleListFull()

148) {
149)   // get list of subdirectories in base directory
150)   typedef std::list<std::string> Subdirlist;
151)   Subdirlist curSubdirs;
152)   m_dirBase.getEntries(Directory::TypeSubdir, curSubdirs);
153) 
154)   // walk through current module list and subdir list simultaneously

155)   Subdirlist::const_iterator    itSubdir = curSubdirs.begin();
156)   typename ModuleList::iterator itEntry  = m_moduleList.begin();

157)   while (itSubdir != curSubdirs.end() || itEntry != m_moduleList.end()) {
158) 
159)     // new module inserted

160)     if (itEntry == m_moduleList.end() ||
161)         (itSubdir != curSubdirs.end() && *itSubdir < itEntry->m_name)) {