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 "CallMgr.h"
17) #include "Directory.h"
18) #include "File.h"

19) #include "InStreamFile.h"

20) #include "IoCallee.h"

21) #include "Module.h"

22) #include "ListTracker.h"

23) #include "Protocol.h"

24) #include "ProtocolFile.h"

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

28) #include "Time.h"

29) #include "TimeCallee.h"

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

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

37) {
38) protected:

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

42)   /// static destination

43)   class Dest;
44) 

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

47) 

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

51) public:
52)   /**
53)    * @brief constructor
54)    * @param[in] callMgr callback manager
55)    * @param[in] streamMgr stream manager
56)    * @param[in] dirBase base directory
57)    */
58)   Sender(CallMgr &callMgr, StreamMgr &streamMgr, const Directory &dirBase);
59) 
60)   /// virtual destructor
61)   virtual ~Sender();
62) 
63) private:
64)   /// copy constructor disabled
65)   Sender(const Sender &that);
66) 
67)   /// assignment operator disabled
68)   const Sender & operator=(const Sender &that);
69) 
70) public:
71)   /// check for update of configuration
72)   virtual void updateConfig();
73) 
74)   /**
75)    * @brief set current frame

76)    * @param[in] stream stream name

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

78)    */

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

80) 

81)   /// callback when requested time reached

82)   virtual void timeCall();
83) 

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

96) protected:

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

99) 

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

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

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

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

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

118)    */

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

120) 

121)   /**

122)    * @brief send protocol data to address

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

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

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

127) 
128)   /**

129)    * @brief convert frame to protocol data

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

131)    * @param[out] data protocol data

132)    */

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

134) 

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

137) 
138) protected:

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

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

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

153) #endif // #ifndef BLINKER_SENDER_H