Control.h

#ifndef GCP_MEDIATOR_CONTROL_H
#define GCP_MEDIATOR_CONTROL_H

#include <list>
#include <vector>

// Shared control code includes

#include "gcp/control/code/unix/libunix_src/specific/rtcnetcoms.h"

// SZA antenna code includes

#include "gcp/util/common/ArrayRegMapDataFrameManager.h"
#include "gcp/util/common/FdSet.h"
#include "gcp/util/common/GenericTask.h"
#include "gcp/util/common/Logger.h"
#include "gcp/util/common/LogMsgHandler.h"
#include "gcp/util/common/NetCommHandler.h"
#include "gcp/util/common/TcpClient.h"

#include "gcp/mediator/specific/ControlMsg.h"
#include "gcp/mediator/specific/TransNetCmdForwarder.h"

#define CONTROL_TASK_FWD_FN(fn) void (fn)(ControlMsg* msg)

namespace gcp {
  namespace mediator {
    
    class Master;
    class MasterMsg;
    class Control;
    class AntennaControl;
    class NetCmdToMsg;
    class GrabberControl;
    class ReceiverControl;
    class WxControl;
    
    class Control : 
      public gcp::util::GenericTask<ControlMsg> {
      
      public:
      
      ~Control();
      
      //------------------------------------------------------------
      // Task message forwarding methods
      //------------------------------------------------------------
      
      CONTROL_TASK_FWD_FN(forwardAntennaControlMsg);
      
      CONTROL_TASK_FWD_FN(forwardControlMsg);
      
      CONTROL_TASK_FWD_FN(forwardGrabberControlMsg);
      
      CONTROL_TASK_FWD_FN(forwardReceiverControlMsg);

      CONTROL_TASK_FWD_FN(forwardWxControlMsg);
      
      void forwardMasterMsg(MasterMsg* msg);
      
      void forwardNetCmd(gcp::util::NetCmd* netCmd);
      
      gcp::util::RegMapDataFrameManager* getArrayShare();
      
      Master* parent() {return parent_;}

      std::string wxHost();

      private:
      
      friend class Master;
      friend class AntennaControl;
      friend class GrabberControl;
      friend class ReceiverControl;
      friend class WxControl;
      
      static Control* control_;
      
      gcp::util::NetCommHandler netCommHandler_;
      
      TransNetCmdForwarder* forwarder_;
      
      gcp::util::LogMsgHandler logMsgHandler_;

      //------------------------------------------------------------
      // Declare startup functions for threads managed by this class.
      //------------------------------------------------------------
      
      static THREAD_START(startAntennaControl);
      
      static THREAD_START(startGrabberControl);
      
      static THREAD_START(startReceiverControl);

      static THREAD_START(startWxControl);
      
      //------------------------------------------------------------
      // Declare cleanup handlers for threads managed by this class.
      //------------------------------------------------------------
      
      static THREAD_CLEAN(cleanAntennaControl);
      
      static THREAD_CLEAN(cleanGrabberControl);
      
      static THREAD_CLEAN(cleanReceiverControl);

      static THREAD_CLEAN(cleanWxControl);
      
      //------------------------------------------------------------
      // Declare methods by which we can ping spawned threads
      //------------------------------------------------------------
      
      static THREAD_PING(pingAntennaControl);
      
      static THREAD_PING(pingGrabberControl);
      
      static THREAD_PING(pingReceiverControl);

      static THREAD_PING(pingWxControl);
      
      Master* parent_;

      AntennaControl*  antennaControl_;
      GrabberControl*  grabberControl_;
      ReceiverControl* receiverControl_;
      WxControl*       wxControl_;
      
      gcp::util::TcpClient client_;
      
      std::string host_;        
      
      bool connected_;     
      
      Control(Master* master);
      
      bool isConnected(); 
      
      bool connect();    
      
      void disconnect(); 
      
      void connectControl(bool reEnable);
      
      void disconnectControl();
      
      void serviceMsgQ();
      
      void sendHeartBeat();
      
      void sendControlConnectedMsg(bool connected);
      
      void sendScriptDoneMsg(unsigned seq);
      
      void sendAntennaInitMsg(bool start);
      
      static void sendNetLogMsg(std::string logStr, bool isErr);

      static LOG_HANDLER_FN(sendLogMsg);
      
      static LOG_HANDLER_FN(sendErrMsg);
      
      void processMsg(ControlMsg* taskMsg);
      
      void respondToHeartBeat();
      
      void packNetMsg(ControlMsg* msg);
      
      static NET_READ_HANDLER(readNetCmdHandler);
      
      static NET_SEND_HANDLER(sendNetMsgHandler);
      
      static NET_ERROR_HANDLER(networkErrorHandler);
      
    }; // End class Control
    
  } // End namespace mediator
} // End namespace gcp

#endif // End #ifndef