MasterMsg.h

#ifndef MASTERMSG_H
#define MASTERMSG_H

#include "gcp/util/common/Exception.h"
#include "gcp/util/common/GenericMasterTaskMsg.h"
#include "gcp/util/common/SignalTask.h"

#include "gcp/mediator/specific/ControlMsg.h"
#include "gcp/mediator/specific/ScannerMsg.h"
#include "gcp/mediator/specific/OptCamMsg.h"

namespace gcp {
namespace mediator {

    class MasterMsg :
      public gcp::util::GenericMasterTaskMsg {
      
      public:
      enum MsgType {
    CONTROL_CONNECTED, // A message that we are dis/connected from
               // the control port
    
    OPTCAM_CONNECTED,  // A message that we are dis/connected from
               // the scanner port
    SCANNER_CONNECTED, // A message that we are dis/connected from
               // the scanner port

    PTEL_CONNECTED,    // A message that the pointing telescope is
               // dis/connected from the ptel port

    DEICING_CONNECTED,    // A message that the deicing control computer is
               // dis/connected from the ptel port

    SEND_HEARTBEAT,
    
    CONTROL_MSG,
    OPTCAM_MSG,
    SCANNER_MSG
      };
      
      MsgType type;
      
      union {
    
    struct {
      bool connected;
    } controlConnected;

    struct {
      bool connected;
    } scannerConnected;

    struct {
      bool connected;
    } optcamConnected;

    struct {
      bool connected;
    } ptelConnected;

    struct {
      bool connected;
    } deicingConnected;

    ControlMsg controlMsg;
    
    OptCamMsg optcamMsg;
    
    ScannerMsg scannerMsg;
    
      } body;
      
      //------------------------------------------------------------
      // Methods for returning pointers to messages for threads
      // managed by this task.
      //------------------------------------------------------------
      
      inline OptCamMsg* getOptCamMsg()
    {
      genericMsgType_ = 
        gcp::util::GenericTaskMsg::TASK_SPECIFIC;
      
      type = OPTCAM_MSG;
      return &body.optcamMsg;
    }
      
      inline ScannerMsg* getScannerMsg()
    {
      genericMsgType_ = 
        gcp::util::GenericTaskMsg::TASK_SPECIFIC;
      
      type = SCANNER_MSG;
      return &body.scannerMsg;
    }
      
      inline ControlMsg* getControlMsg()
    {
      genericMsgType_ = 
        gcp::util::GenericTaskMsg::TASK_SPECIFIC;
      
      type = CONTROL_MSG;
      return &body.controlMsg;
    }
      
      
      //------------------------------------------------------------
      // Methods for packing messages.
      
      inline void packSendHeartBeatMsg()
    {
      genericMsgType_ = 
        gcp::util::GenericTaskMsg::TASK_SPECIFIC;
      
      type = SEND_HEARTBEAT;
    }
      
      inline void packControlConnectedMsg(bool connected)
    {
      genericMsgType_ = 
        gcp::util::GenericTaskMsg::TASK_SPECIFIC;
      
      type = CONTROL_CONNECTED;
      
      body.controlConnected.connected = connected;
    }

      inline void packPtelControlConnectedMsg(bool connected)
    {
      genericMsgType_ = 
        gcp::util::GenericTaskMsg::TASK_SPECIFIC;
      
      type = PTEL_CONNECTED;
      
      body.ptelConnected.connected = connected;
    }

      inline void packDeicingControlConnectedMsg(bool connected)
    {
      genericMsgType_ = 
        gcp::util::GenericTaskMsg::TASK_SPECIFIC;
      
      type = DEICING_CONNECTED;
      
      body.deicingConnected.connected = connected;
    }

      inline void packScannerConnectedMsg(bool connected)
    {
      genericMsgType_ = 
        gcp::util::GenericTaskMsg::TASK_SPECIFIC;
      
      type = SCANNER_CONNECTED;
      
      body.scannerConnected.connected = connected;
    }

      inline void packOptCamConnectedMsg(bool connected)
    {
      genericMsgType_ = 
        gcp::util::GenericTaskMsg::TASK_SPECIFIC;
      
      type = OPTCAM_CONNECTED;
      
      body.optcamConnected.connected = connected;
    }
      
    }; // End class MasterMsg
    
} // End namespace mediator
} // End namespace gcp
  
#endif // End #ifndef