SignalTask.h

Go to the documentation of this file.

#ifndef SIGNALTASK_H
#define SIGNALTASK_H

#include <string>
#include <vector>

#include "carma/szautil/AbsTimer.h"
#include "carma/szautil/GenericTask.h"
#include "carma/szautil/SignalTaskMsg.h"

#include <pthread.h>

namespace sza {
  namespace util {
    
    class Thread;

    class SignalTask :
      public sza::util::
      GenericTask<sza::util::SignalTaskMsg> {
      
      public:
      
      SignalTask(bool spawnThread = false);
      
      virtual ~SignalTask();
      
      void sendInstallTimerMsg(std::string name,
                               int sigNo, 
                               unsigned long initSec,
                               unsigned long initNsec,
                               unsigned long intervalSec,
                               unsigned long intervaNsec,
                               SIGNALTASK_HANDLER_FN(*handler));
      
      void sendAddHandlerMsg(std::string name,
                             SIGNALTASK_HANDLER_FN(*handler), 
                             bool add);

      void sendInstallSignalMsg(int sigNo, SIGNALTASK_HANDLER_FN(*handler),
                                void* arg=NULL);
      
      void sendAddHandlerMsg(int sigNo,
                             SIGNALTASK_HANDLER_FN(*handler), 
                             bool add);

      void sendEnableTimerMsg(std::string name, bool enable);
      
      void stopTimers();
      
      int getIoSig();
      
      virtual void run();
      
      void serviceMsgQ();
      
      pthread_t getThreadId();

      protected:
      
      class TimerInfo {
      public:
        TimerInfo(std::string name, 
                  int sigNo, 
                  unsigned long initSec, 
                  unsigned long initNsec,
                  unsigned long intervalSec, 
                  unsigned long intervalNsec);
        
        ~TimerInfo();
        
        void reArm();
        
      private:
        
        friend class SignalTask;
        
        int sigNo_;       // The signal to handle.
        unsigned long initSec_;      // The intial delay, in seconds,
                                     // of this timer.
        unsigned long initNsec_;     // The initial delay, in
                                     // nanoseconds, of this timer.
        unsigned long intervalSec_;  // The interval, in seconds, of
                                     // this timer.
        unsigned long intervalNsec_; // The interval, in nanoseconds,
                                     // of this timer.
        std::string name_;     // A name for this timer
        bool enabled_;    // True when this timer is enabled
        AbsTimer* timer_; // The timer.
      };
      
      class SignalHandler {
      public:
        
        SignalHandler(int sigNo, SIGNALTASK_HANDLER_FN(*handler), void* arg=NULL);
        
        SignalHandler(int sigNo,
                      SIGNALTASK_HANDLER_FN(*handler), 
                      TimerInfo* timer,
                      void* arg=NULL); 
        
        void reArm();
        
        ~SignalHandler();

        void addHandler(SIGNALTASK_HANDLER_FN(*handler), void* arg=NULL);
          
        void removeHandler(SIGNALTASK_HANDLER_FN(*handler));

      private:
        
        friend class SignalTask;
        
        int sigNo_;      
        
        struct HandlerPair {

          HandlerPair(SIGNALTASK_HANDLER_FN(*handler), void* args) {
            handler_ = handler;
            args_ = args;
          }

          SIGNALTASK_HANDLER_FN(*handler_);
          void* args_;
        };

        std::vector<HandlerPair> handlers_;
        
        TimerInfo* timer_;
      };
      
      protected:
      
      sigset_t handledSignals_;
      
      private:
      
      void privateConstructor();
      
      int sigIo_;  
      
      pthread_t id_;
      
      static SignalTask* signaltask_;
      
      std::vector<TimerInfo*> timers_;

      // Members for managing a spawned thread

      Thread* spawnedThread_;

      bool spawned_; 
      
      static THREAD_START(startUp);

      std::vector<SignalHandler*> signalHandlers_;
      
      void installTimer(SignalTaskMsg* msg);
      
      void installTimer(std::string name, 
                        int sigNo, 
                        unsigned long initSec, 
                        unsigned long initNsec,
                        unsigned long intervalSec, 
                        unsigned long intervalNsec,
                        SIGNALTASK_HANDLER_FN(*handler));
      
      void addHandler(std::string name, SIGNALTASK_HANDLER_FN(*handler), void* args=NULL);

      void removeHandler(std::string name, SIGNALTASK_HANDLER_FN(*handler));

      SignalHandler* getHandler(int sigNo);

      TimerInfo* getTimer(int sigNo);

      TimerInfo* getTimer(std::string name);

      void installSignal(SignalTaskMsg* msg);
      
      void installSignal(int sigNo, SIGNALTASK_HANDLER_FN(*handler), void* arg=NULL);
      
      void addHandler(int sigNo, SIGNALTASK_HANDLER_FN(*handler), void* args=NULL);

      void removeHandler(int sigNo, SIGNALTASK_HANDLER_FN(*handler));

      void enableTimer(SignalTaskMsg* msg);
      
      void startTimer(std::string name);
      
      void stopTimer(std::string name);
      
      void startTimers();
      
      void processTaskMsg(bool* stop);
      
      static SIGNALTASK_HANDLER_FN(checkMsgQ);
      
      void fwdTaskMsg(SignalTaskMsg* msg);
      
    }; // End class SignalTask
  }; // End namespace util
}; // End namespace sza

#endif // End #ifndef