Blinker

@@ -33,16 +33,17 @@ class Sender: public IoCallee, public Module, public StreamRecv,

 {

 protected:

   /// static destination

-  struct Dest {

+  class Dest;

+

+  /// static destination list entry

+  struct DestEntry {

     std::string m_name;   ///< name of static destination

-    SettingFile m_file; ///< setting file object

-    ADDR        m_addr; ///< parsed address

-    Dest(const std::string &name, const File &file); ///< constructor

-    bool parse();       ///< parse address from current file

+    Dest        *m_pDest; ///< static destination object

+    DestEntry(const std::string &name); ///< constructor

   };

   /// static destinations

-  typedef std::list<Dest> Dests;

+  typedef std::list<DestEntry> DestList;

   /// dynamic destinations: address -> time of last request

   typedef std::map<ADDR, Time> DynDests;

@@ -99,6 +100,12 @@ public:

   virtual void ioWriteCall(Io *io);

 protected:

+  /**

+   * @brief free static destiation list

+   * @param[in] destList static destination list to free

+   */

+  void freeDestList(DestList &destList);

+

   /// get input stream and attach to it

   void getInStream();

@@ -114,20 +121,19 @@ protected:

   /**

    * @brief light update of static destinations,

    *        i.e. stat all files in current static destination directory

-   * @param[in] dests static destinations for protocol

-   * @param[in] proto Blinken protocol identifier

+   * @param[in] destList static destinations for protocol

    */

-  void updateDestsLight(Dests &dests, etBlinkenProto proto);

+  void updateDestsLight(DestList &destList);

   /**

    * @brief full update of static destinations,

    *        i.e. scan files in playlist directory

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

-   * @param[in] dests static destinations for protocol

-   * @param[in] proto Blinken protocol identifier

+   * @param[in] destList static destinations for protocol

+   * @param[in] pNoFrameData "no frame" protocaol data

    */

-  void updateDestsFull(Directory &dirDests, Dests &dests,

-                       etBlinkenProto proto);

+  void updateDestsFull(Directory &dirDests, DestList &destList,

+                       const std::string *pNoFrameData);

   /// remove timed-out dynamic destinations

   void removeTimedOutDynDests();

@@ -143,17 +149,18 @@ protected:

   /**

    * @brief send data to static/dynamic destinations

-   * @param[in] data data to send

-   * @param[in] dests static destinations

+   * @param[in] data *pData protocol data to send

+   * @param[in] destList static destinations

    * @param[in] dynDests dynamic destinations

    */

-  void sendDests(const std::string &data, const Dests dests,

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

                  const DynDests dynDests);

   /**

    * @brief send current frame to address

    * @param[in] addr address to send to

    * @param[in] proto Blinken protocol identifier

+   TODO: still needed?

    */

   void sendCurFrame(const ADDR &addr, etBlinkenProto proto) const;

@@ -161,6 +168,7 @@ protected:

    * @brief send "no frame" to address

    * @param[in] addr address to send to

    * @param[in] proto Blinken protocol identifier

+   TODO: still needed?

    */

   void sendNoFrame(const ADDR &addr, etBlinkenProto proto) const;

@@ -199,626 +207,20 @@ protected:

   std::string m_nameInStream;    ///< name of input stream

   Stream      *m_pInStream;      ///< input stream

   SOCK        *m_pSock;          ///< socket to use for sending streams

-  Dests       m_destsBlp;     ///< static BLP destinations

-  Dests       m_destsEblp;    ///< static EBLP destinations

-  Dests       m_destsMcuf;    ///< static MCUF destinations

+  DestList    m_destListBlp;     ///< static BLP destinations

+  DestList    m_destListEblp;    ///< static EBLP destinations

+  DestList    m_destListMcuf;    ///< static MCUF destinations

   DynDests    m_dynDestsBlp;     ///< dynamic BLP destinations

   DynDests    m_dynDestsEblp;    ///< dynamic EBLP destinations

   DynDests    m_dynDestsMcuf;    ///< dynamic MCUF destinations

+  std::string m_noFrameDataBlp;  ///< "no frame" BLP protocol data

+  std::string m_noFrameDataEblp; ///< "no frame" EBLP protocol data

+  std::string m_noFrameDataMcuf; ///< "no frame" MCUF protocol data

+  std::string m_dataBlp;         ///< current BLP protocol data

+  std::string m_dataEblp;        ///< current BLP protocol data

+  std::string m_dataMcuf;        ///< current BLP protocol data

 }; // class Sender

-/* ##########

-   # Sender #

-   ########## */

-

-/**

- * @brief constructor

- * @param[in] callMgr callback manager

- * @param[in] streamMgr stream manager

- * @param[in] dirBase base directory

- */

-template<typename ADDR, typename SOCK>

-Sender<ADDR, SOCK>::Sender(CallMgr &callMgr, StreamMgr &streamMgr,

-                           const Directory &dirBase):

-  Module(callMgr, streamMgr, dirBase),

-  m_fileInStream(dirBase.getFile("instream")),

-  m_fileBind(dirBase.getFile("bind")),

-  m_dirDestsBlp(dirBase.getSubdir("blp")),

-  m_dirDestsEblp(dirBase.getSubdir("eblp")),

-  m_dirDestsMcuf(dirBase.getSubdir("mcuf")),

-  m_pInStream(NULL),

-  m_pSock(NULL)

-{

-  // get input stream and attach to it

-  getInStream();

-  // create and bind socket

-  createSock();

-

-  // load static destinations

-  updateDestsFull(m_dirDestsBlp, m_destsBlp, BlinkenProtoBlp);

-  updateDestsFull(m_dirDestsEblp, m_destsEblp, BlinkenProtoEblp);

-  updateDestsFull(m_dirDestsMcuf, m_destsMcuf, BlinkenProtoMcuf);

-}

-

-/// virtual destructor

-template<typename ADDR, typename SOCK>

-Sender<ADDR, SOCK>::~Sender()

-{

-  // send "no frame" to all destinations

-  sendAllNoFrame();

-

-  // destroy socket

-  destroySock();

-  // detach from input stream and release it

-  releaseInStream();

-  // cancel time callback

-  m_callMgr.cancelTimeCall(this);

-}

-

-/// check for update of configuration

-template<typename ADDR, typename SOCK>

-void Sender<ADDR, SOCK>::updateConfig()

-{

-  // input stream name file was modified -> re-get input stream

-  if (m_fileInStream.checkModified()) {

-    releaseInStream();

-    getInStream();

-  }

-

-  // bind address file was modified -> re-create socket

-  if (m_fileBind.checkModified()) {

-    destroySock();

-    createSock();

-  }

-

-  // static destinations update

-  // (directory modified -> full, otherwise -> light)

-  if (m_dirDestsBlp.checkModified())

-    updateDestsFull(m_dirDestsBlp, m_destsBlp, BlinkenProtoBlp);

-  else

-    updateDestsLight(m_destsBlp, BlinkenProtoBlp);

-  if (m_dirDestsEblp.checkModified())

-    updateDestsFull(m_dirDestsEblp, m_destsEblp, BlinkenProtoEblp);

-  else

-    updateDestsLight(m_destsEblp, BlinkenProtoEblp);

-  if (m_dirDestsMcuf.checkModified())

-    updateDestsFull(m_dirDestsMcuf, m_destsMcuf, BlinkenProtoMcuf);

-  else

-    updateDestsLight(m_destsMcuf, BlinkenProtoMcuf);

-}

-

-/**

- * @brief set current frame

- * @param[in] stream stream name

- * @param[in] pFrame current frame

- */

-template<typename ADDR, typename SOCK>

-void Sender<ADDR, SOCK>::setFrame(const std::string &stream,

-                                  stBlinkenFrame *pFrame)

-{

-  // send frame to all destinations

-  sendAllFrame(pFrame);

-

-  (void)stream; // unused

-}

-

-/**

- * @brief set current frame to none

- * @param[in] stream stream name

- */

-template<typename ADDR, typename SOCK>

-void Sender<ADDR, SOCK>::setNoFrame(const std::string &stream)

-{

-  // send "no frame" to all destinations

-  sendAllNoFrame();

-

-  (void)stream; // unused

-}

-

-/// callback when requsted time reached

-template<typename ADDR, typename SOCK>

-void Sender<ADDR, SOCK>::timeCall()

-{

-  stBlinkenFrame *pFrame;

-  std::string data;

-

-  // get current frame from stream

-  if (m_pInStream && m_pInStream->getCurFrame(pFrame))

-    // repeat frame to all destinations

-    sendAllFrame(pFrame);

-

-  // no stream of no current frame

-  else

-    // repeat "no frame" to all destinations

-    sendAllNoFrame();

-}

-

-/**

- * @brief callback when I/O object is readable

- * @param[in] io I/O object that is readable

- */

-template<typename ADDR, typename SOCK>

-void Sender<ADDR, SOCK>::ioReadCall(Io *io)

-{

-  // reception on socket

-  if (io == m_pSock)

-    receiveFromSock();

-}

-

-/**

- * @brief callback when I/O object is writable

- * @param[in] io I/O object that is writable

- */

-template<typename ADDR, typename SOCK>

-void Sender<ADDR, SOCK>::ioWriteCall(Io *io)

-{

-  (void)io; // unused

-}

-

-/// get input stream and attach to it

-template<typename ADDR, typename SOCK>

-void Sender<ADDR, SOCK>::getInStream()

-{

-  // get input stream

-  m_fileInStream.getStr(m_nameInStream);

-  m_pInStream = &m_streamMgr.refStream(m_nameInStream);

-

-  // attach to input stream

-  if (m_pInStream)

-    m_pInStream->attach(this);

-}

-

-/// detach from input stream and release it

-template<typename ADDR, typename SOCK>

-void Sender<ADDR, SOCK>::releaseInStream()

-{

-  // detach from input stream

-  if (m_pInStream)

-    m_pInStream->detach(this);

-

-  // unreference stream

-  m_pInStream = NULL;

-  m_streamMgr.unrefStream(m_nameInStream);

-}

-

-/// create socket and bind it

-template<typename ADDR, typename SOCK>

-void Sender<ADDR, SOCK>::createSock()

-{

-  std::string strAddr;

-  ADDR addr;

-

-  // create socket

-  if (!m_pSock) {

-    m_pSock = new SOCK();

-    if (!m_pSock)

-      return;

-  }

-

-  // get bind address from bind address setting file

-  if (!m_fileBind.getStr(strAddr) || !addr.fromStr(strAddr)) {

-    delete m_pSock;

-    m_pSock = NULL;

-    return;

-  }

-

-  // bind socket

-  if (!m_pSock->bind(addr)) {

-    delete m_pSock;

-    m_pSock = NULL;

-    return;

-  }

-

-  // request callback on recpetion

-  m_callMgr.requestIoReadCall(this, m_pSock);

-}

-

-/// destroy socket

-template<typename ADDR, typename SOCK>

-void Sender<ADDR, SOCK>::destroySock()

-{

-  // send "no frame" to all destinations

-  // (stream from this socket will stop now)

-  sendAllNoFrame();

-

-  // clear dynamic destinations

-  // (they registered with this socket adn this socket is gone)

-  m_dynDestsBlp.clear();

-  m_dynDestsEblp.clear();

-  m_dynDestsMcuf.clear();

-

-  // cancel callback request

-  m_callMgr.cancelIoReadCall(this, m_pSock);

-

-  // destroy socket

-  if (m_pSock) {

-    delete m_pSock;

-    m_pSock = NULL;

-  }

-}

-

-/**

- * @brief light update of static destinations,

- *        i.e. stat all files in current static destination directory

- * @param[in] dests static destinations for one protocol

- * @param[in] proto Blinken protocol identifier

- */

-template<typename ADDR, typename SOCK>

-void Sender<ADDR, SOCK>::updateDestsLight(Dests &dests, etBlinkenProto proto)

-{

-  // walk through all files in static dest dir and check for modification

-  typename Dests::iterator itDest = dests.begin();

-  while (itDest != dests.end()) {

-

-    // address changed

-    if (itDest->m_file.checkModified()) {

-      // send "no frame" to old address

-      sendNoFrame(itDest->m_addr, proto);

-      // re-load address

-      if (!itDest->parse()) {

-        // parsing address failed -> remove destination

-        itDest = dests.erase(itDest);

-        // do not advance to next destination

-        continue;

-      }

-      // send current frame to new address

-      sendCurFrame(itDest->m_addr, proto);

-    }

-

-    // advance to next destination

-    ++itDest;

-

-  } // while itDest

-}

-

-/**

- * @brief full update of static destinations,

- *        i.e. scan files in playlist directory

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

- * @param[in] dests static destinations for protocol

- * @param[in] proto Blinken protocol identifier

- */

-template<typename ADDR, typename SOCK>

-void Sender<ADDR, SOCK>::updateDestsFull(Directory &dirDests, Dests &dests,

-                                         etBlinkenProto proto)

-{

-  // get list of files in static destinations directory

-  typedef std::list<std::string> Filelist;

-  Filelist curFiles;

-  dirDests.getEntries(Directory::TypeFile, curFiles);

-

-  // walk through current static destinations and file list simultaneously

-  Filelist::const_iterator itFile = curFiles.begin();

-  typename Dests::iterator itDest = dests.begin();

-  while (itFile != curFiles.end() || itDest != dests.end()) {

-

-    // new static destination inserted

-    if (itDest == dests.end() ||

-        (itFile != curFiles.end() && *itFile < itDest->m_name)) {

-      // parse new address

-      Dest dest(*itFile, dirDests.getFile(*itFile));

-      if (dest.parse()) {

-        // insert new static destination

-        dests.insert(itDest, dest);

-        // send current frame to new static destination

-        sendCurFrame(itDest->m_addr, proto);

-      }

-      // advance to next file

-      ++itFile;

-    }

-

-    // static destination removed

-    // static destination changed (=> remove and re-insert in next iteration)

-    else if (itFile == curFiles.end() || *itFile > itDest->m_name ||

-             itDest->m_file.checkModified()) {

-      // send "no frame" to old static destination

-      sendNoFrame(itDest->m_addr, proto);

-      // remove static destination

-      itDest = dests.erase(itDest);

-      // do not advance to next file

-    }

-

-    // static destination stayed in playlist and did not change

-    else {

-      // advance to next file and next static destination

-      ++itFile;

-      ++itDest;

-    }

-

-  } // while itFile itDest

-}

-

-/// remove timed-out dynamic destinations

-template<typename ADDR, typename SOCK>

-void Sender<ADDR, SOCK>::removeTimedOutDynDests()

-{

-  Time now, timeout;

-  typename DynDests::iterator itDyn;

-

-  now = Time::now();

-  timeout = Time(30);

-

-  for (itDyn = m_dynDestsBlp.begin(); itDyn != m_dynDestsBlp.end(); )

-    if (itDyn->second + timeout < now)

-      m_dynDestsBlp.erase(itDyn++);

-    else

-      ++itDyn;

-  for (itDyn = m_dynDestsEblp.begin(); itDyn != m_dynDestsEblp.end(); )

-    if (itDyn->second + timeout < now)

-      m_dynDestsEblp.erase(itDyn++);

-    else

-      ++itDyn;

-  for (itDyn = m_dynDestsMcuf.begin(); itDyn != m_dynDestsMcuf.end(); )

-    if (itDyn->second + timeout < now)

-      m_dynDestsMcuf.erase(itDyn++);

-    else

-      ++itDyn;

-}

-

-/**

- * @brief send frame to all destinations

- * @param[in] pFrame frame to send

- */

-template<typename ADDR, typename SOCK>

-void Sender<ADDR, SOCK>::sendAllFrame(stBlinkenFrame *pFrame)

-{

-  std::string data;

-

-  // remove timed-out dynamic destinations

-  removeTimedOutDynDests();

-

-  // convert frame to protocol data and send to all static/dynamic destinations

-  if (!m_destsBlp.empty() || !m_dynDestsBlp.empty()) {

-    frame2data(pFrame, BlinkenProtoBlp, data);

-    sendDests(data, m_destsBlp, m_dynDestsBlp);

-  }

-  if (!m_destsEblp.empty() || !m_dynDestsEblp.empty()) {

-    frame2data(pFrame, BlinkenProtoEblp, data);

-    sendDests(data, m_destsEblp, m_dynDestsEblp);

-  }

-  if (!m_destsMcuf.empty() || !m_dynDestsMcuf.empty()) {

-    frame2data(pFrame, BlinkenProtoMcuf, data);

-    sendDests(data, m_destsMcuf, m_dynDestsMcuf);

-  }

-

-  // request time callback in one second

-  m_callMgr.requestTimeCall(this, Time::now() + Time(1));

-}

-

-/// send "no frame" to all destinations

-template<typename ADDR, typename SOCK>

-void Sender<ADDR, SOCK>::sendAllNoFrame()

-{

-  std::string data;

-

-  // remove timed-out dynamic destinations

-  removeTimedOutDynDests();

-

-  // get "no frame" protocol data and send to all static/dynamic destinations

-  if (!m_destsBlp.empty() || !m_dynDestsBlp.empty()) {

-    noFrame2data(BlinkenProtoBlp, data);

-    sendDests(data, m_destsBlp, m_dynDestsBlp);

-  }

-  if (!m_destsEblp.empty() || !m_dynDestsEblp.empty()) {

-    noFrame2data(BlinkenProtoEblp, data);

-    sendDests(data, m_destsEblp, m_dynDestsEblp);

-  }

-  if (!m_destsMcuf.empty() || !m_dynDestsMcuf.empty()) {

-    noFrame2data(BlinkenProtoMcuf, data);

-    sendDests(data, m_destsMcuf, m_dynDestsMcuf);

-  }

-

-  // request time callback in one second

-  m_callMgr.requestTimeCall(this, Time::now() + Time(1));

-}

-

-/**

- * @brief send data to static/dynamic destinations

- * @param[in] data data to send

- * @param[in] dests static destinations

- * @param[in] dynDests dynamic destinations

- */

-template<typename ADDR, typename SOCK>

-void Sender<ADDR, SOCK>::sendDests(const std::string &data, const Dests dests,

-                                   const DynDests dynDests)

-{

-  // send data to static destinations

-  typename Dests::const_iterator itDest;

-  for (itDest = dests.begin(); itDest != dests.end(); ++itDest)

-    sendFrame(data, itDest->m_addr);

-

-  // send data to all dynamic destinations

-  typename DynDests::const_iterator itDyn;

-  for (itDyn = dynDests.begin(); itDyn != dynDests.end(); ++itDyn)

-    sendFrame(data, itDyn->first);

-}

-

-/**

- * @brief send current frame to address

- * @param[in] addr address to send to

- * @param[in] proto Blinken protocol identifier

- */

-template<typename ADDR, typename SOCK>

-void Sender<ADDR, SOCK>::sendCurFrame(const ADDR &addr,

-                                      etBlinkenProto proto) const

-{

-  stBlinkenFrame *pFrame;

-  std::string data;

-

-  // get current frame from stream

-  if (m_pInStream && m_pInStream->getCurFrame(pFrame)) {

-    // convert frame to protocal data

-    frame2data(pFrame, proto, data);

-    // send frame to address

-    sendFrame(data, addr);

-  }

-

-  // no stream of no current frame

-  else {

-    // get "no frame" ad protocal data

-    noFrame2data(proto, data);

-    // send "no frame" to address

-    sendFrame(data, addr);

-  }

-}

-

-/**

- * @brief send "no frame" to address

- * @param[in] addr address to send to

- * @param[in] proto Blinken protocol identifier

- */

-template<typename ADDR, typename SOCK>

-void Sender<ADDR, SOCK>::sendNoFrame(const ADDR &addr,

-                                     etBlinkenProto proto) const

-{

-  std::string data;

-

-  // get "no frame" ad protocal data

-  noFrame2data(proto, data);

-

-  // send "no frame" to address

-  sendFrame(data, addr);

-}

-

-/**

- * @brief send frame to address

- * @param[in] data protocol data of frame

- * @param[in] addr address to send to

- */

-template<typename ADDR, typename SOCK>

-void Sender<ADDR, SOCK>::sendFrame(const std::string &data,

-                                   const ADDR &addr) const

-{

-  if (m_pSock) {

-    m_pSock->send(data, addr);

-  }

-}

-

-/**

- * @brief convert frame to protocol data

- * @param[in] pFrame frame

- * @param[in] proto Blinken protocol identifier

- * @param[out] data protocol data

- */

-template<typename ADDR, typename SOCK>

-void Sender<ADDR, SOCK>::frame2data(stBlinkenFrame *pFrame,

-                                    etBlinkenProto proto, std::string &data)

-{

-  char buf[65536];

-  int len;

-

-  // convert frame to protcol data

-  len = BlinkenFrameToNetwork(pFrame, proto, buf, sizeof(buf));

-  if (len < 0)

-    len = 0;

-  data.assign(buf, len);

-}

-

-/**

- * @brief get "no frame" protocol data

- * @param[in] proto Blinken protocol identifier

- * @param[out] data protcol data

- */

-template<typename ADDR, typename SOCK>

-void Sender<ADDR, SOCK>::noFrame2data(etBlinkenProto proto, std::string &data)

-{

-  char buf[16];

-  int len;

-

-  // obtain "no frame" protcol data

-  len = BlinkenProtoMakePacket(proto, BlinkenPacketStreamEnd,

-        buf, sizeof(buf));

-  if (len < 0)

-    len = 0;

-  data.assign(buf, len);

-}

-

-/// receive data from socket

-template<typename ADDR, typename SOCK>

-void Sender<ADDR, SOCK>::receiveFromSock()

-{

-  etBlinkenProto proto;

-  etBlinkenPacket packet;

-  std::string data;

-  ADDR addr;

-

-  // make sure socket exists

-  if (!m_pSock)

-    return;

-

-  // receive (leave if no reception)

-  if (!m_pSock->recv(data, addr))

-    return;

-

-  // detect packet type and protocol

-  BlinkenProtoDetectPacket(data.c_str(), data.size(), &proto, &packet);

-

-  switch (packet) {

-

-    // request -> add to dynamic destinations and send current frame

-    case BlinkenPacketRequest:

-      switch (proto) {

-        case BlinkenProtoBlp:

-          m_dynDestsBlp[addr] = Time::now();

-          sendCurFrame(addr, BlinkenProtoBlp);

-          break;

-        case BlinkenProtoEblp:

-          m_dynDestsEblp[addr] = Time::now();

-          sendCurFrame(addr, BlinkenProtoEblp);

-          break;

-        case BlinkenProtoMcuf:

-          m_dynDestsMcuf[addr] = Time::now();

-          sendCurFrame(addr, BlinkenProtoMcuf);

-          break;

-        default:

-          break;

-      }

-      break;

-

-    // end request -> remove from dynamic destinations

-    case BlinkenPacketEndRequest:

-      switch (proto) {

-        case BlinkenProtoBlp:

-          m_dynDestsBlp.erase(addr);

-          break;

-        case BlinkenProtoEblp:

-          m_dynDestsEblp.erase(addr);

-          break;

-        case BlinkenProtoMcuf:

-          m_dynDestsMcuf.erase(addr);

-          break;

-        default:

-          break;

-      }

-      break;

-

-    default:

-      break;

-

-  } // switch (packet)

-

-}

-

-/* ################

-   # Sender::Dest #

-   ################ */

-

-/// constructor

-template<typename ADDR, typename SOCK>

-Sender<ADDR, SOCK>::Dest::Dest(const std::string &name, const File &file):

-  m_name(name),

-  m_file(file)

-{

-}

-

-/// parse address from current file

-template<typename ADDR, typename SOCK>

-bool Sender<ADDR, SOCK>::Dest::parse()

-{

-  std::string strAddr;

-  return m_file.getStr(strAddr) && m_addr.fromStr(strAddr);

-}

-

 } // namespace Blinker

 #endif // #ifndef SENDER_H

@@ -0,0 +1,75 @@

+/* Blinker

+   Copyright 2011 Stefan Schuermans <stefan@blinkenarea.org>

+   Copyleft GNU public license - http://www.gnu.org/copyleft/gpl.html

+   a blinkenarea.org project */

+

+#ifndef SENDERDEST_H

+#define SENDERDEST_H

+

+#include <string>

+

+#include "Directory.h"

+#include "File.h"

+#include "Module.h"

+#include "Sender.h"

+#include "SettingFile.h"

+

+namespace Blinker {

+

+/// static destination of a stream sender

+template<typename ADDR, typename SOCK>

+class Sender<ADDR, SOCK>::Dest

+{

+public:

+  /**

+   * @brief constructor

+   * @param[in] sender owning sender object

+   * @param[in] dirBase base directory

+   * @param[in] pNoFrameData protocol data for "no frame" packet

+   */

+  Dest(Sender &sender, const Directory &dirBase,

+       const std::string *pNoFrameData);

+

+  /// destructor

+  ~Dest();

+

+private:

+  /// copy constructor disabled

+  Dest(const Dest &that);

+

+  /// assignment operator disabled

+  const Dest & operator=(const Dest &that);

+

+public:

+  /// check for update of configuration

+  void updateConfig();

+

+  /**

+   * @brief set current protocol data

+   * @param[in] pData protocol data to send to address

+   */

+  void setProtoData(const std::string *pData);

+

+protected:

+  /// (re-)get address

+  void getAddr();

+

+  /**

+   * @brief send protocol data to address

+   * @param[in] pData protocol data to send to address

+   */

+  void send(const std::string *pData);

+

+protected:

+  Sender            &m_sender;       ///< owning sender object

+  SettingFile       m_fileAddr;      ///< address file

+  ADDR              m_addr;          ///< address

+  bool              m_haveAddr;      ///< if address is available

+  const std::string *m_pNoFrameData; ///< protocol data for "no frame" packet

+  const std::string *m_pData;        ///< protocol data to send to address

+}; // class Sender<ADDr, SOCK>::Dest

+

+} // namespace Blinker

+

+#endif // #ifndef SENDERDEST_H

+

@@ -0,0 +1,100 @@

+/* Blinker

+   Copyright 2011 Stefan Schuermans <stefan@blinkenarea.org>

+   Copyleft GNU public license - http://www.gnu.org/copyleft/gpl.html

+   a blinkenarea.org project */

+

+#ifndef SENDERDEST_IMPL_H

+#define SENDERDEST_IMPL_H

+

+#include <string>

+

+#include "Directory.h"

+#include "File.h"

+#include "Module.h"

+#include "Sender.h"

+#include "SenderDest.h"

+#include "SettingFile.h"

+

+namespace Blinker {

+

+/**

+ * @brief constructor

+ * @param[in] sender owning sender object

+ * @param[in] dirBase base directory

+ * @param[in] pNoFrameData protocol data for "no frame" packet

+ */

+template<typename ADDR, typename SOCK>

+Sender<ADDR, SOCK>::Dest::Dest(Sender &sender, const Directory &dirBase,

+                               const std::string *pNoFrameData):

+  m_sender(sender),

+  m_fileAddr(dirBase.getFile("addr")),

+  m_haveAddr(false),

+  m_pNoFrameData(pNoFrameData),

+  m_pData(pNoFrameData)

+{

+  // set up

+  getAddr();

+}

+

+/// destructor

+template<typename ADDR, typename SOCK>

+Sender<ADDR, SOCK>::Dest::~Dest()

+{

+  // send "no frame" protocol data to old address

+  send(m_pNoFrameData);

+}

+

+/// check for update of configuration

+template<typename ADDR, typename SOCK>

+void Sender<ADDR, SOCK>::Dest::updateConfig()

+{

+  // address file was modified -> re-get address

+  if (m_fileAddr.checkModified())

+    getAddr();

+}

+

+/**

+ * @brief set current protocol data

+ * @param[in] pData protocol data to send to address

+ */

+template<typename ADDR, typename SOCK>

+void Sender<ADDR, SOCK>::Dest::setProtoData(const std::string *pData)

+{

+  // remember new data

+  m_pData = pData;

+

+  // send new protocol data to current address

+  send(m_pData);

+}

+

+/// (re-)get address

+template<typename ADDR, typename SOCK>

+void Sender<ADDR, SOCK>::Dest::getAddr()

+{

+  std::string strAddr;

+

+  // send "no frame" protocol data to old address

+  send(m_pNoFrameData);

+

+  // parse new address from file

+  m_haveAddr = m_fileAddr.getStr(strAddr) && m_addr.fromStr(strAddr);

+

+  // send current protocol data to new address

+  send(m_pData);

+}

+

+/**

+ * @brief send protocol data to address

+ * @param[in] pData protocol data to send to address

+ */

+template<typename ADDR, typename SOCK>

+void Sender<ADDR, SOCK>::Dest::send(const std::string *pData)

+{

+  if (m_sender.m_pSock && m_haveAddr && pData)

+    m_sender.m_pSock->send(*pData, m_addr);

+}

+

+} // namespace Blinker

+

+#endif // #ifndef SENDERDEST_IMPL_H

+

@@ -0,0 +1,637 @@

+/* Blinker

+   Copyright 2011 Stefan Schuermans <stefan@blinkenarea.org>

+   Copyleft GNU public license - http://www.gnu.org/copyleft/gpl.html

+   a blinkenarea.org project */

+

+#ifndef SENDER_IMPL_H

+#define SENDER_IMPL_H

+

+#include <list>

+#include <map>

+#include <string>

+

+#include <BlinkenLib/BlinkenProto.h>

+#include <BlinkenLib/BlinkenFrame.h>

+

+#include "CallMgr.h"

+#include "Directory.h"

+#include "File.h"

+#include "IoCallee.h"

+#include "Module.h"

+#include "Sender.h"

+#include "SenderDest.h"

+#include "SenderDest_impl.h"

+#include "SettingFile.h"

+#include "StreamMgr.h"

+#include "StreamRecv.h"

+#include "Time.h"

+#include "TimeCallee.h"

+

+namespace Blinker {

+

+/**

+ * @brief constructor

+ * @param[in] callMgr callback manager

+ * @param[in] streamMgr stream manager

+ * @param[in] dirBase base directory

+ */

+template<typename ADDR, typename SOCK>

+Sender<ADDR, SOCK>::Sender(CallMgr &callMgr, StreamMgr &streamMgr,

+                           const Directory &dirBase):

+  Module(callMgr, streamMgr, dirBase),

+  m_fileInStream(dirBase.getFile("instream")),

+  m_fileBind(dirBase.getFile("bind")),

+  m_dirDestsBlp(dirBase.getSubdir("blp")),

+  m_dirDestsEblp(dirBase.getSubdir("eblp")),

+  m_dirDestsMcuf(dirBase.getSubdir("mcuf")),

+  m_pInStream(NULL),

+  m_pSock(NULL)

+{

+  // initialize protocol data buffers

+  noFrame2data(BlinkenProtoBlp, m_noFrameDataBlp);

+  noFrame2data(BlinkenProtoEblp, m_noFrameDataEblp);

+  noFrame2data(BlinkenProtoMcuf, m_noFrameDataMcuf);

+  m_dataBlp = m_noFrameDataBlp;

+  m_dataEblp = m_noFrameDataEblp;

+  m_dataMcuf = m_noFrameDataMcuf;

+

+  // get input stream and attach to it

+  getInStream();

+  // create and bind socket

+  createSock();

+

+  // load static destinations

+  updateDestsFull(m_dirDestsBlp, m_destListBlp, &m_noFrameDataBlp);

+  updateDestsFull(m_dirDestsEblp, m_destListEblp, &m_noFrameDataEblp);

+  updateDestsFull(m_dirDestsMcuf, m_destListMcuf, &m_noFrameDataMcuf);

+}

+

+/// virtual destructor

+template<typename ADDR, typename SOCK>

+Sender<ADDR, SOCK>::~Sender()

+{

+  // send "no frame" to all destinations

+  sendAllNoFrame();

+

+  // free static destination lists

+  freeDestList(m_destListBlp);

+  freeDestList(m_destListEblp);

+  freeDestList(m_destListMcuf);

+

+  // destroy socket

+  destroySock();

+  // detach from input stream and release it

+  releaseInStream();

+  // cancel time callback

+  m_callMgr.cancelTimeCall(this);

+}

+

+/// check for update of configuration

+template<typename ADDR, typename SOCK>

+void Sender<ADDR, SOCK>::updateConfig()

+{

+  // input stream name file was modified -> re-get input stream

+  if (m_fileInStream.checkModified()) {

+    releaseInStream();

+    getInStream();

+  }

+

+  // bind address file was modified -> re-create socket

+  if (m_fileBind.checkModified()) {

+    destroySock();

+    createSock();

+  }

+

+  // static destinations update

+  // (directory modified -> full, otherwise -> light)

+  if (m_dirDestsBlp.checkModified())

+    updateDestsFull(m_dirDestsBlp, m_destListBlp, &m_noFrameDataBlp);

+  else

+    updateDestsLight(m_destListBlp);

+  if (m_dirDestsEblp.checkModified())

+    updateDestsFull(m_dirDestsEblp, m_destListEblp, &m_noFrameDataEblp);

+  else

+    updateDestsLight(m_destListEblp);

+  if (m_dirDestsMcuf.checkModified())

+    updateDestsFull(m_dirDestsMcuf, m_destListMcuf, &m_noFrameDataMcuf);

+  else

+    updateDestsLight(m_destListMcuf);

+}

+

+/**

+ * @brief set current frame

+ * @param[in] stream stream name

+ * @param[in] pFrame current frame

+ */

+template<typename ADDR, typename SOCK>

+void Sender<ADDR, SOCK>::setFrame(const std::string &stream,

+                                  stBlinkenFrame *pFrame)

+{

+  // send frame to all destinations

+  sendAllFrame(pFrame);

+

+  (void)stream; // unused

+}

+

+/**

+ * @brief set current frame to none

+ * @param[in] stream stream name

+ */

+template<typename ADDR, typename SOCK>

+void Sender<ADDR, SOCK>::setNoFrame(const std::string &stream)

+{

+  // send "no frame" to all destinations

+  sendAllNoFrame();

+

+  (void)stream; // unused

+}

+

+/// callback when requsted time reached

+template<typename ADDR, typename SOCK>

+void Sender<ADDR, SOCK>::timeCall()

+{

+  stBlinkenFrame *pFrame;

+  std::string data;

+

+  // get current frame from stream

+  if (m_pInStream && m_pInStream->getCurFrame(pFrame))

+    // repeat frame to all destinations

+    sendAllFrame(pFrame);

+

+  // no stream of no current frame

+  else

+    // repeat "no frame" to all destinations

+    sendAllNoFrame();

+}

+

+/**

+ * @brief callback when I/O object is readable

+ * @param[in] io I/O object that is readable

+ */

+template<typename ADDR, typename SOCK>

+void Sender<ADDR, SOCK>::ioReadCall(Io *io)

+{

+  // reception on socket

+  if (io == m_pSock)

+    receiveFromSock();

+}

+

+/**

+ * @brief callback when I/O object is writable

+ * @param[in] io I/O object that is writable

+ */

+template<typename ADDR, typename SOCK>

+void Sender<ADDR, SOCK>::ioWriteCall(Io *io)

+{

+  (void)io; // unused

+}

+

+/**

+ * @brief free static destiation list

+ * @param[in] destList static destination list to free

+ */

+template<typename ADDR, typename SOCK>

+void Sender<ADDR, SOCK>::freeDestList(DestList &destList)

+{

+  while (!destList.empty()) {

+    delete destList.back().m_pDest;

+    destList.pop_back();