AntennaControl.h

#ifndef GCP_MEDIATOR_ANTENNACONTROL_H
#define GCP_MEDIATOR_ANTENNACONTROL_H

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

#include "gcp/util/common/GenericTask.h"
#include "gcp/util/common/LogMsgHandler.h"
#include "gcp/util/common/NetCommHandler.h"
#include "gcp/util/common/NetStr.h"
#include "gcp/util/common/TcpListener.h"
#include "gcp/util/common/TimeVal.h"

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

namespace gcp {
  namespace mediator {
    
    class Control;
    
    class AntennaControl :
      public gcp::util::GenericTask<AntennaControlMsg> {
      
      public:
      
      AntennaControl(Control* parent);
      
      virtual ~AntennaControl();
      
      private:
      
      friend class Control;

      Control* parent_;

      static AntennaControl* control_;

      int nAntenna_;
      
      gcp::util::TcpListener* listener_;
      
      gcp::util::NetCommHandler temporaryHandler_; 
      
      std::vector<gcp::util::NetCommHandler*> connectedHandlers_; 

      std::list<AntennaControlMsg> initScript_;

      std::list<AntennaControlMsg>::iterator initScriptIter_;

      bool recordingInitScript_;

      bool initInProgress_;

      enum InitState {
    UNINITIALIZED,
    INITIALIZING,
    INITIALIZED
      };

      std::vector<InitState> antennaInitState_;
      
      enum ConnectState {
    DISCONNECTED,
    PENDING,
    CONNECTED
      };

      std::vector<ConnectState> antennaConnectState_;

      std::vector<bool> sendPending_;

      gcp::util::LogMsgHandler logMsgHandler_;

      void setPending(unsigned iant, bool pending);

      int nConnected_;
      
      gcp::util::TimeVal startTime_;
      gcp::util::TimeVal timer_;
      struct timeval* timeOut_;

      unsigned int pending_;

      bool haveControlConnection(unsigned short iant);
      
      void connectTcpIp();
      
      void processMsg(AntennaControlMsg* taskMsg);
      
      void processAntennaDriveMsg(AntennaControlMsg* taskMsg);
      
      void processTrackerMsg(AntennaControlMsg* taskMsg);
      
      void sendRtcNetCmd(AntennaControlMsg* msg);

      void decrementPending();

      static NET_SEND_HANDLER(netMsgSentHandler);

      static NET_SEND_HANDLER(netCmdSentHandler);
   
      static NET_ERROR_HANDLER(netErrorHandler);

      //------------------------------------------------------------
      // Methods to do with antenna initialization
      //------------------------------------------------------------
   
      void setInitState(InitState state);

      void recordInitMsg(AntennaControlMsg* msg);

      void beginInitScript();

      void sendNextInitMsg();
    
      void endInitScript();

      void sendNavUpdateMsg();

      bool haveAntennasReady();
  
      void flagAntenna(AntennaControlMsg* msg);

      bool listening();
      
      void serviceMsgQ();
      
      void initializeConnection();

      void finalizeConnection(); 

      void terminateConnection(gcp::util::NetCommHandler* str, bool shutdown=true);
      
      void terminateConnection(unsigned short iant, bool shutdown=true);

      void bufferLogMsg(gcp::util::NetMsg* msg);

      // Forward a net message to the control task

      void forwardNetMsg(gcp::util::NetMsg* msg);

      void sendGreetingMsg(gcp::util::NetCommHandler* netHandler);

      static NET_READ_HANDLER(processTemporaryNetMsg);
      static NET_READ_HANDLER(processNetMsg);

      void listen(bool restartListening);

      bool timedOut();

      void startRecordingInitScript();

      void stopRecordingInitScript();

    }; // End class AntennaControl
    
} // End namespace mediator
} // End namespace gcp
  
#endif // End #ifndef