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] mgrs managers

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

56)   Sender(Mgrs &mgrs, const Directory &dirBase);

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

74)    * @param[in] stream stream name

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

76)    */

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

78) 

79)   /// callback when requested time reached

80)   virtual void timeCall();
81) 

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

94) protected:

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

97) 

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

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

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

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

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

116)    */

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

118) 

119)   /**

120)    * @brief send protocol data to address

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

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

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

125) 
126)   /**

127)    * @brief convert frame to protocol data

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

129)    * @param[out] data protocol data

130)    */

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

132) 

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

135) 
136) protected:

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

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

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

151) #endif // #ifndef BLINKER_SENDER_H