Master.h

#ifndef SZA_TRANSLTOR_MASTER_H
#define SZA_TRANSLTOR_MASTER_H

#include <vector>

#include "gcp/mediator/specific/MasterMsg.h"

#include "gcp/util/specific/Directives.h"

#include "gcp/util/common/ArrayRegMapDataFrameManager.h"
#include "gcp/util/common/GenericMasterTask.h"
#include "gcp/util/common/SignalTask.h"

#define HEARTBEAT_SIGNAL       SIGRTMIN
#define DATAFRAME_SIGNAL       SIGRTMIN+1
#define CONNECT_SIGNAL         SIGRTMIN+2

#define HEARTBEAT_SEC   60
#define DATAFRAME_NSEC  1000000000 // Every second
#define CONNECT_SEC     2
#define WX_FRAME_COUNT  60  // Read the weather station every 30 seconds
                // (60 half-second frames)

#define MASTER_TASK_FWD_FN(fn) void (fn)(MasterMsg* msg)

namespace gcp {
namespace mediator {
    
    class Control;
    class Scanner;
    
    class Master : 
      public gcp::util::GenericMasterTask<MasterMsg> { 
      
      public:
      
      //============================================================
      // Master public members & methods
      //============================================================
      
      Master(std::string ctlHost,
         std::string wxHost,
         bool sim,
         bool simRx);

      ~Master();
      
      //------------------------------------------------------------
      // All task messages will be sent to the Master via
      // the following message forwarding function.  On receipt of a
      // message, the master will determine which task is the
      // intended recipient, and forward it appropriately via the
      // private task forwarding methods below.
      //
      // The idea is that when a task is spawned by
      // Master, it is guaranteed that the
      // Master msgQ already exists, while there is no
      // guarantee that the msgQs of the other tasks have yet been
      // created. 
      //
      // By forwarding all messages through the master, we are
      // therefore guaranteed that a task will never attempt to
      // access the message queue or methods of another task before
      // the resources of that task have been allocated.  We are
      // also guaranteed that a message will never be lost because
      // all messages will be queued until the master runs its
      // serviceMsgQ() method, which happens only after all spawned
      // tasks are running theirs.
      
      MASTER_TASK_FWD_FN(forwardMasterMsg);
      
      std::string ctlHost() {
    return ctlHost_;
      }

      std::string wxHost()  {
    return wxHost_;
      }

      gcp::util::ArrayRegMapDataFrameManager& getArrayShare();

      bool sim() {return sim_;}
      bool simRx() {return simRx_;}

      private:
      
      //============================================================
      // Master private members & methods
      //============================================================
      
      bool sim_;
      bool simRx_;

      static Master* master_;
      
      gcp::util::ArrayRegMapDataFrameManager arrayShare_;

      std::string ctlHost_;
      std::string wxHost_;

      //------------------------------------------------------------
      // Thread management methods
      //------------------------------------------------------------
      
      static THREAD_START(startControl); 
      static THREAD_START(startScanner); 
      static THREAD_START(startSignal);  
      
      static THREAD_CLEAN(cleanControl); 
      static THREAD_CLEAN(cleanScanner); 
      static THREAD_CLEAN(cleanSignal);  
      
      static THREAD_PING(pingControl); 
      static THREAD_PING(pingScanner); 
      
      //------------------------------------------------------------
      // The thread startup functions will instantiate these objects
      //------------------------------------------------------------
      
      Control* control_;
      
      Scanner* scanner_; 
      
      //------------------------------------------------------------
      // Static functions which will be passed to the
      // Signal class as callbacks on receipt of signals.
      //------------------------------------------------------------
      
      static SIGNALTASK_HANDLER_FN(sendSendHeartBeatMsg);
      
      static SIGNALTASK_HANDLER_FN(sendSendRestartMsg);
      
      static SIGNALTASK_HANDLER_FN(sendShutDownMsg);
      
      static SIGNALTASK_HANDLER_FN(trapSegv);

      static SIGNALTASK_HANDLER_FN(sendStartDataFrameMsg);
      
      static SIGNALTASK_HANDLER_FN(sendScannerConnectMsg);
      
      static SIGNALTASK_HANDLER_FN(sendControlConnectMsg);
      
      //------------------------------------------------------------
      // Message forwarding methods for spawned tasks.
      //------------------------------------------------------------
      
      MASTER_TASK_FWD_FN(forwardControlMsg);
      
      MASTER_TASK_FWD_FN(forwardScannerMsg);
      
      //------------------------------------------------------------
      // Methods called in response to messages received on the
      // Master msgQ.
      //------------------------------------------------------------
      
      void sendHeartBeat();
      
      void restart();
      
      void installSignals();
      
      void installTimers();

      void processMsg(MasterMsg* taskMsg);
      
    }; // End class Master
    
} // End namespace mediator
} // End namespace gcp
  
#endif // End #ifndef