SignalTask.h

Go to the documentation of this file.

#ifndef SIGNALTASK_H
#define SIGNALTASK_H

#include <string>
#include <vector>

#include "gcp/util/common/AbsTimer.h"
#include "gcp/util/common/GenericTask.h"
#include "gcp/util/common/SignalTaskMsg.h"

namespace gcp {
  namespace util {
    
    class Thread;
    
    class SignalTask :
      public gcp::util::
      GenericTask<gcp::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();
      
      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 itself
      };
      
      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 gcp


#endif // End #ifndef