GenericMasterTaskMsg.h

Go to the documentation of this file.

#ifndef GENERICMASTERTASKMSG_H
#define GENERICMASTERTASKMSG_H

#include "gcp/util/common/GenericTaskMsg.h"
#include "gcp/util/common/LogStream.h"

#include <string.h>

#define SIGNALTASK_HANDLER_FN(fn) void (fn)(int sigNo, void* args)
#define SIGNAL_NAME_LEN 10

namespace gcp {
  namespace util {
    
    class GenericMasterTaskMsg : public GenericTaskMsg {
      
    public:
      
      enum GenericMasterMsgType {
    ADD_HANDLER = GenericTaskMsg::LAST+1,    // Add a signal handler
    ENABLE_TIMER,   // Enable/Disable a timer
    INSTALL_TIMER,  // Install a timer
    INSTALL_SIGNAL, // Install a signal
    TASK_SPECIFIC   // A task-specific message
      };
      
      union {
    struct {
      char name[SIGNAL_NAME_LEN+1];
      int sigNo;
      unsigned long initSec;
      unsigned long initNsec;
      unsigned long intervalSec;
      unsigned long intervalNsec;
      SIGNALTASK_HANDLER_FN(*handler);
    } installTimer;
    
    struct {
      int sigNo;
      SIGNALTASK_HANDLER_FN(*handler);
      void* args;
    } installSignal;
    
    struct {
      char name[SIGNAL_NAME_LEN+1];
      bool enable;
    } enableTimer;
    
    struct {
      char name[SIGNAL_NAME_LEN+1];
      SIGNALTASK_HANDLER_FN(*handler);
      void* args;
      bool add;
    } addHandler;
    
      } genericMasterBody;
      
      inline void packInstallTimerMsg(std::string name, 
                      int sigNo, 
                      unsigned long initSec, 
                      unsigned long initNsec, 
                      unsigned long intervalSec, 
                      unsigned long intervalNsec, 
                      SIGNALTASK_HANDLER_FN(*handler)) 
    {
      genericMsgType_ = (GenericTaskMsg::GenericMsgType)
        gcp::util::GenericMasterTaskMsg::INSTALL_TIMER;
      
      if(name.size() > SIGNAL_NAME_LEN)
        ThrowError("name string is too long");
      
      strncpy(genericMasterBody.installTimer.name, name.c_str(), 
          SIGNAL_NAME_LEN);
      genericMasterBody.installTimer.sigNo        = sigNo;
      genericMasterBody.installTimer.initSec      = initSec;
      genericMasterBody.installTimer.initNsec     = initNsec;
      genericMasterBody.installTimer.intervalSec  = intervalSec;
      genericMasterBody.installTimer.intervalNsec = intervalNsec;
      genericMasterBody.installTimer.handler      = handler;
    }
      
      inline void packInstallTimerMsg(std::string name, 
                      int sigNo, 
                      unsigned long intervalSec, 
                      unsigned long intervalNsec, 
                      SIGNALTASK_HANDLER_FN(*handler)) 
    {
      genericMsgType_ = (GenericTaskMsg::GenericMsgType)
        gcp::util::GenericMasterTaskMsg::INSTALL_TIMER;
      
      if(name.size() > SIGNAL_NAME_LEN)
        ThrowError("Name string is too long");
      
      strncpy(genericMasterBody.installTimer.name, name.c_str(), 
          SIGNAL_NAME_LEN);
      genericMasterBody.installTimer.sigNo        = sigNo;
      genericMasterBody.installTimer.initSec      = intervalSec;
      genericMasterBody.installTimer.initNsec     = intervalNsec;
      genericMasterBody.installTimer.intervalSec  = intervalSec;
      genericMasterBody.installTimer.intervalNsec = intervalNsec;
      genericMasterBody.installTimer.handler      = handler;
    }
      
      inline void packInstallSignalMsg(int sigNo, 
                       SIGNALTASK_HANDLER_FN(*handler))
    {
      genericMsgType_ = (GenericTaskMsg::GenericMsgType)
        gcp::util::GenericMasterTaskMsg::INSTALL_SIGNAL;
      
      genericMasterBody.installSignal.sigNo   = sigNo;
      genericMasterBody.installSignal.handler = handler;
    }
      
      inline void packEnableTimerMsg(std::string name, 
                     bool enable)
    {
      genericMsgType_ = (GenericTaskMsg::GenericMsgType)
        gcp::util::GenericMasterTaskMsg::ENABLE_TIMER;
      
      if(name.size() > SIGNAL_NAME_LEN)
        ThrowError("name std::string is too long");
      
      strncpy(genericMasterBody.enableTimer.name, name.c_str(), 
          SIGNAL_NAME_LEN);
      
      genericMasterBody.enableTimer.enable = enable;
    }
      
      inline void packAddHandlerMsg(std::string name, 
                    SIGNALTASK_HANDLER_FN(*handler),
                    bool add)
    {
      genericMsgType_ = (GenericTaskMsg::GenericMsgType)
        gcp::util::GenericMasterTaskMsg::ADD_HANDLER;
      
      if(name.size() > SIGNAL_NAME_LEN)
        ThrowError("name std::string is too long");
      
      strncpy(genericMasterBody.addHandler.name, name.c_str(), 
          SIGNAL_NAME_LEN);
      
      genericMasterBody.addHandler.handler = handler;
      genericMasterBody.addHandler.add     = add;
    }
      
    }; // End class GenericMasterTaskMsg
    
  } // End namespace util
} // End namespace gcp


#endif // End #ifndef