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 BLINKER_PHONE_H
7) #define BLINKER_PHONE_H
8) 

9) #include <map>

10) #include <string>
11) 
12) #include "Directory.h"
13) #include "File.h"
14) #include "IoCallee.h"

15) #include "ListTracker.h"

16) #include "Mgrs.h"
17) #include "Module.h"
18) #include "SettingFile.h"
19) #include "Time.h"
20) #include "TimeCallee.h"
21) 
22) namespace Blinker {
23) 
24) /// phone connector (using EBIP)
25) template<typename ADDR, typename SOCK>
26) class Phone: public IoCallee, public Module, public TimeCallee
27) {
28) protected:
29)   /// type for address setting file
30)   typedef SettingFile<ADDR> AddrFile;
31) 

32)   /// extension to be called
33)   class Extension;
34) 
35)   /// extension list tracker
36)   typedef ListTracker<Phone, Extension, Directory> ExtListTracker;
37) 
38)   /// map of extensions to call (extension name  -> module name)
39)   typedef std::map<std::string, std::string> ExtMap;
40) 

41) public:
42)   /**
43)    * @brief constructor
44)    * @param[in] mgrs managers
45)    * @param[in] dirBase base directory
46)    */
47)   Phone(Mgrs &mgrs, const Directory &dirBase);
48) 
49)   /// virtual destructor
50)   virtual ~Phone();
51) 
52) private:
53)   /// copy constructor disabled
54)   Phone(const Phone &that);
55) 
56)   /// assignment operator disabled
57)   const Phone & operator=(const Phone &that);
58) 
59) public:
60)   /// check for update of configuration
61)   virtual void updateConfig();
62) 
63)   /// callback when requested time reached
64)   virtual void timeCall();
65) 
66)   /**
67)    * @brief callback when I/O object is readable
68)    * @param[in] io I/O object that is readable
69)    */
70)   virtual void ioReadCall(Io *io);
71) 
72)   /**
73)    * @brief callback when I/O object is writable
74)    * @param[in] io I/O object that is writable
75)    */
76)   virtual void ioWriteCall(Io *io);
77) 
78) protected:
79)   /// (re-)read server address
80)   void readServer();
81) 
82)   /// create socket and bind it
83)   void createSock();
84) 
85)   /// destroy socket
86)   void destroySock();
87) 
88)   /// register with server
89)   void sendRegister();
90) 
91)   /// send heartbeat to server
92)   void sendHeartbeat();
93) 
94)   /**
95)    * @brief send message to server
96)    * @param[in] msg message to send
97)    */
98)   void send(const std::string &msg);
99) 
100)   /// receive data from socket
101)   void receiveFromSock();
102) 

103)   /**
104)    * @brief process message from server
105)    * @param[in] msg message from server
106)    */
107)   void serverMsg(const std::string &msg);
108) 

109)   /// update time callback
110)   void updateTimeCallback();
111) 
112) protected:
113)   static const Time m_serverTimeout;
114)   static const Time m_heartbeatInterval;
115) 
116) protected:

117)   AddrFile       m_fileBind;       ///< bind address file
118)   AddrFile       m_fileServer;     ///< server address file
119)   ExtListTracker m_extListTracker; ///< extension tracker
120)   SOCK           *m_pSock;         ///< socket to use for sending messages
121)   Time           m_timeRegister;   ///< time to re-register
122)   Time           m_timeHeartbeat;  ///< time to send next heartbeat
123)   ExtMap         m_extMap;         ///< map of extensions to call