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 SENDER_H
7) #define 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 "IoCallee.h"

20) #include "Module.h"
21) #include "SettingFile.h"
22) #include "StreamMgr.h"
23) #include "StreamRecv.h"

24) #include "Time.h"

25) #include "TimeCallee.h"

26) 
27) namespace Blinker {
28) 
29) /// stream sender
30) template<typename ADDR, typename SOCK>

31) class Sender: public IoCallee, public Module, public StreamRecv,
32)               public TimeCallee

33) {
34) protected:
35)   /// static destination

36)   class Dest;
37) 
38)   /// static destination list entry
39)   struct DestEntry {
40)     std::string m_name;   ///< name of static destination
41)     Dest        *m_pDest; ///< static destination object
42)     DestEntry(const std::string &name); ///< constructor

43)   };
44) 
45)   /// static destinations

46)   typedef std::list<DestEntry> DestList;

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 requsted 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)   /**
98)    * @brief free static destiation list
99)    * @param[in] destList static destination list to free
100)    */
101)   void freeDestList(DestList &destList);
102) 

103)   /// get input stream and attach to it
104)   void getInStream();
105) 
106)   /// detach from input stream and release it
107)   void releaseInStream();
108) 
109)   /// create socket and bind it
110)   void createSock();
111) 
112)   /// destroy socket
113)   void destroySock();
114) 
115)   /**
116)    * @brief light update of static destinations,
117)    *        i.e. stat all files in current static destination directory

118)    * @param[in] destList static destinations for protocol

119)    */

120)   void updateDestsLight(DestList &destList);

121) 
122)   /**
123)    * @brief full update of static destinations,
124)    *        i.e. scan files in playlist directory

125)    * @param[in] dirDests static destinations directory for protocol

126)    * @param[in] destList static destinations for protocol

127)    * @param[in] pNoFrameData "no frame" protocol data

128)    */

129)   void updateDestsFull(Directory &dirDests, DestList &destList,
130)                        const std::string *pNoFrameData);

131) 

132)   /// remove timed-out dynamic destinations
133)   void removeTimedOutDynDests();
134) 

135)   /// send current protocol data to all destinations
136)   void sendAllProto();

137) 
138)   /// send "no frame" to all destinations
139)   void sendAllNoFrame();
140) 
141)   /**
142)    * @brief send data to static/dynamic destinations

143)    * @param[in] data *pData protocol data to send
144)    * @param[in] destList static destinations

145)    * @param[in] dynDests dynamic destinations
146)    */

147)   void sendDests(const std::string *pData, const DestList destList,

148)                  const DynDests dynDests);
149) 

150)   /**

151)    * @brief send protocol data to address

152)    * @param[in] data protcol data of frame

153)    * @param[in] addr address to send to
154)    */

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

156) 
157)   /**

158)    * @brief convert frame to protocol data

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

160)    * @param[in] proto Blinken protocol identifier
161)    * @param[out] data protcol data

162)    */

163)   static void frame2data(stBlinkenFrame *pFrame, etBlinkenProto proto,
164)                          std::string &data);

165) 

166)   /// receive data from socket
167)   void receiveFromSock();

168) 
169) protected:

170)   SettingFile m_fileInStream;    ///< input stream name file
171)   SettingFile m_fileBind;        ///< bind address file
172)   Directory   m_dirDestsBlp;     ///< static BLP destinations directory
173)   Directory   m_dirDestsEblp;    ///< static EBLP destinations directory
174)   Directory   m_dirDestsMcuf;    ///< static MCUF destinations directory
175)   std::string m_nameInStream;    ///< name of input stream
176)   Stream      *m_pInStream;      ///< input stream
177)   SOCK        *m_pSock;          ///< socket to use for sending streams
178)   DestList    m_destListBlp;     ///< static BLP destinations
179)   DestList    m_destListEblp;    ///< static EBLP destinations
180)   DestList    m_destListMcuf;    ///< static MCUF destinations
181)   DynDests    m_dynDestsBlp;     ///< dynamic BLP destinations
182)   DynDests    m_dynDestsEblp;    ///< dynamic EBLP destinations
183)   DynDests    m_dynDestsMcuf;    ///< dynamic MCUF destinations
184)   std::string m_noFrameDataBlp;  ///< "no frame" BLP protocol data
185)   std::string m_noFrameDataEblp; ///< "no frame" EBLP protocol data
186)   std::string m_noFrameDataMcuf; ///< "no frame" MCUF protocol data
187)   std::string m_dataBlp;         ///< current BLP protocol data
188)   std::string m_dataEblp;        ///< current BLP protocol data
189)   std::string m_dataMcuf;        ///< current BLP protocol data