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_SENDER_H
7) #define BLINKER_SENDER_H

8) 
9) #include <list>

10) #include <map>

11) #include <string>
12) 

13) #include <BlinkenLib/BlinkenProto.h>

14) #include <BlinkenLib/BlinkenFrame.h>
15) 
16) #include "Directory.h"
17) #include "File.h"

18) #include "InStreamFile.h"

19) #include "IoCallee.h"

20) #include "Mgrs.h"

21) #include "Module.h"

22) #include "ListTracker.h"

23) #include "Protocol.h"

24) #include "ProtocolFile.h"

25) #include "SettingFile.h"
26) #include "StreamRecv.h"

27) #include "Time.h"

28) #include "TimeCallee.h"

29) 
30) namespace Blinker {
31) 
32) /// stream sender
33) template<typename ADDR, typename SOCK>

34) class Sender: public IoCallee, public Module, public StreamRecv,
35)               public TimeCallee

36) {
37) protected:

38)   /// type for address setting file
39)   typedef SettingFile<ADDR> AddrFile;
40) 

41)   /// static destination

42)   class Dest;
43) 

44)   /// static destination list tracker
45)   typedef ListTracker<Sender, Dest, Directory> DestListTracker;

46) 

47)   /// dynamic destinations: address -> time of last request
48)   typedef std::map<ADDR, Time> DynDests;
49) 

50) public:
51)   /**
52)    * @brief constructor

53)    * @param[in] name module name

54)    * @param[in] mgrs managers

55)    * @param[in] dirBase base directory
56)    */

57)   Sender(const std::string &name, Mgrs &mgrs, const Directory &dirBase);

58) 
59)   /// virtual destructor
60)   virtual ~Sender();
61) 
62) private:
63)   /// copy constructor disabled
64)   Sender(const Sender &that);
65) 
66)   /// assignment operator disabled
67)   const Sender & operator=(const Sender &that);
68) 
69) public:
70)   /// check for update of configuration
71)   virtual void updateConfig();
72) 
73)   /**
74)    * @brief set current frame

75)    * @param[in] stream stream name

76)    * @param[in] pFrame current frame (NULL for none)

77)    */

78)   virtual void setFrame(const std::string &stream, stBlinkenFrame *pFrame);

79) 

80)   /// callback when requested time reached

81)   virtual void timeCall();
82) 

83)   /**
84)    * @brief callback when I/O object is readable
85)    * @param[in] io I/O object that is readable
86)    */
87)   virtual void ioReadCall(Io *io);
88) 
89)   /**
90)    * @brief callback when I/O object is writable
91)    * @param[in] io I/O object that is writable
92)    */
93)   virtual void ioWriteCall(Io *io);
94) 

95) protected:

96)   /// (re-)read protocol
97)   void readProto();

98) 

99)   /// create socket and bind it
100)   void createSock();
101) 
102)   /// destroy socket
103)   void destroySock();
104) 

105)   /// remove timed-out dynamic destinations
106)   void removeTimedOutDynDests();
107) 

108)   /// send current protocol data to all destinations
109)   void sendAllProto();

110) 
111)   /// send "no frame" to all destinations
112)   void sendAllNoFrame();
113) 
114)   /**
115)    * @brief send data to static/dynamic destinations

116)    * @param[in] data *pData protocol data to send

117)    */

118)   void sendDests(const std::string *pData);

119) 

120)   /**

121)    * @brief send protocol data to address

122)    * @param[in] data protocol data of frame (empty if unknown)

123)    * @param[in] addr address to send to
124)    */

125)   void sendProto(const std::string &data, const ADDR &addr) const;

126) 
127)   /**

128)    * @brief convert frame to protocol data

129)    * @param[in] pFrame frame (NULL for none)

130)    * @param[out] data protocol data

131)    */

132)   void frame2data(stBlinkenFrame *pFrame, std::string &data) const;

133) 

134)   /// receive data from socket
135)   void receiveFromSock();

136) 
137) protected:

138)   InStreamFile    m_fileInStream;    ///< input stream name file
139)   AddrFile        m_fileBind;        ///< bind address file
140)   ProtocolFile    m_fileProtocol;    ///< protocol file
141)   SOCK            *m_pSock;          ///< socket to use for sending streams
142)   DestListTracker m_destListTracker; ///< static destinations tracker
143)   DynDests        m_dynDests;        ///< dynamic destinations

144)   std::string     m_noFrameData;     /**< "no frame" protocol data
145)                                           (empty if unknown) */
146)   std::string     m_data;            /**< current protocol data
147)                                           (empty if unknown) */

148) }; // class Sender
149) 
150) } // namespace Blinker
151) 

152) #endif // #ifndef BLINKER_SENDER_H