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 "InStreamFile.h"

20) #include "IoCallee.h"

21) #include "Module.h"

22) #include "Protocol.h"

23) #include "ProtocolFile.h"

24) #include "SettingFile.h"
25) #include "StreamMgr.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 entry
45)   struct DestEntry {
46)     std::string m_name;   ///< name of static destination
47)     Dest        *m_pDest; ///< static destination object
48)     DestEntry(const std::string &name); ///< constructor

49)   };
50) 
51)   /// static destinations

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

53) 

54)   /// dynamic destinations: address -> time of last request
55)   typedef std::map<ADDR, Time> DynDests;
56) 

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

82)    * @param[in] stream stream name

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

84)    */

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

86) 

87)   /// callback when requsted time reached
88)   virtual void timeCall();
89) 

90)   /**
91)    * @brief callback when I/O object is readable
92)    * @param[in] io I/O object that is readable
93)    */
94)   virtual void ioReadCall(Io *io);
95) 
96)   /**
97)    * @brief callback when I/O object is writable
98)    * @param[in] io I/O object that is writable
99)    */
100)   virtual void ioWriteCall(Io *io);
101) 

102) protected:

103)   /// (re-)read protocol
104)   void readProto();

105) 

106)   /// create socket and bind it
107)   void createSock();
108) 
109)   /// destroy socket
110)   void destroySock();
111) 
112)   /**
113)    * @brief light update of static destinations,
114)    *        i.e. stat all files in current static destination directory
115)    */

116)   void updateDestsLight();

117) 
118)   /**
119)    * @brief full update of static destinations,
120)    *        i.e. scan files in playlist directory
121)    */

122)   void updateDestsFull();

123) 

124)   /// remove timed-out dynamic destinations
125)   void removeTimedOutDynDests();
126) 

127)   /// send current protocol data to all destinations
128)   void sendAllProto();

129) 
130)   /// send "no frame" to all destinations
131)   void sendAllNoFrame();
132) 
133)   /**
134)    * @brief send data to static/dynamic destinations

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

136)    */

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

138) 

139)   /**

140)    * @brief send protocol data to address

141)    * @param[in] data protcol data of frame (empty if unknown)

142)    * @param[in] addr address to send to
143)    */

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

145) 
146)   /**

147)    * @brief convert frame to protocol data

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

149)    * @param[out] data protcol data

150)    */

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

152) 

153)   /// receive data from socket
154)   void receiveFromSock();

155) 
156) protected:

157)   InStreamFile m_fileInStream; ///< input stream name file
158)   AddrFile     m_fileBind;     ///< bind address file
159)   ProtocolFile m_fileProtocol; ///< protocol file
160)   Directory    m_dirDests;     ///< static destinations directory
161)   SOCK         *m_pSock;       ///< socket to use for sending streams
162)   DestList     m_destList;     ///< static destinations
163)   DynDests     m_dynDests;     ///< dynamic destinations
164)   std::string  m_noFrameData;  ///< "no frame" protocol data (empty if unknown)
165)   std::string  m_data;         ///< current protocol data (empty if unknown)