---

CTask.hpp

Go to the documentation of this file.

#ifndef CTask_h
#define CTask_h 1

#include <ace/Task.h>
#include <ace/Synch.h>

#include <string>

// CTaskException
#include "jic/exc/CTaskException.hpp"
// CStateObservable
#include "jic/base/CStateObservable.hpp"
// STaskCounters
#include "jic/task/STaskCounters.hpp"

namespace TASK {
  class CTasksControler;

} // namespace TASK

namespace TASK {

  typedef ACE_Task<ACE_MT_SYNCH> ACE_Task;

  typedef enum {eByControler,eByMessage} EStoppingWay;

  //    Durante la creacion de un task se indica como se para.
  //    Teniendo dos opciones:
  //
  //    - Por defecto se parará a través del CTasksControler
  //    (singleton)
  //    - Si se indica lo contrario se hará a través de un
  //    mensaje de control que se enviará desde la tarea a la
  //    cual se ha conectado.
  //
  //    Notas:
  //    - con la segunda opción se puede dar el caso de que la
  //    tarea no se conecte. Esto es un error de programación.
  //    - El objeto no es instanciable

  class CTask : public ACE_Task  
  {

    public:
        CTask();

        CTask (std::string strName, int nThreads = 1, CTasksControler *pTaskControler = 0);

        virtual ~CTask();

        void resetCounters ();

        virtual EStoppingWay stoppingWay ();

        virtual void start () throw (CTaskException);

        //      La parada es sincrona
        virtual void stop ();

        //      Especifica el tamaño de las colas
        void setWaterMarks (size_t high, size_t low);

        const CStateObservable & getState ();

        //      Acctiones a realizar justo antes de una parada
        virtual void stopActions ();

        //      Acctiones a realizar justo al arrancar (se ejecutan una
        //      vez arrancados todos los threads)
        virtual void startActions ();

        //      Acctiones a realizar justo antes de terminar el ultimo
        //      thread.
        virtual void termActions ();

        const std::string get_strName () const;

        const int get_nNumThreads () const;

        const CTasksControler * get_pTaskControler () const;

        const int get_nRunningThreads () const;

        const STaskCounters get_taskCounters () const;

      // Additional Public Declarations

    protected:

        virtual void step () = 0;

        virtual void preStoppingActions ();

        void incInputCounter ();

        void incOutputCounter ();

      // Data Members for Class Attributes

        //      Flag para representar el estado en el cual se le ha
        //      pedido parar a la tarea
        bool m_bToStop;

        ACE_Thread_Mutex m_stateMutex;

        ACE_Thread_Mutex m_countersMutex;

        //      Flag que indica si esta tarea no esta encadenada o si lo
        //      está es la primera de la cadena.
        bool m_bIsHeadTask;

      // Additional Protected Declarations

    private:
        CTask(const CTask &right);

        CTask & operator=(const CTask &right);

        virtual int close (u_long flags = 0);

        virtual int svc ();

        void init ();

        //      Versión de svc para cuando la task se ejecuta en el
        //      thread principal
        virtual int svcMain ();

      // Additional Private Declarations

    private: 
      // Data Members for Class Attributes

        std::string m_strName;

        int m_nNumThreads;

        CTasksControler *m_pTaskControler;

        ACE_Barrier m_barrier;

        int m_nRunningThreads;

      // Data Members for Associations

        STaskCounters m_taskCounters;

        CStateObservable m_state;

      // Additional Implementation Declarations

  };

  // Class TASK::CTask 

  inline const std::string CTask::get_strName () const
  {
    return m_strName;
  }

  inline const int CTask::get_nNumThreads () const
  {
    return m_nNumThreads;
  }

  inline const CTasksControler * CTask::get_pTaskControler () const
  {
    return m_pTaskControler;
  }

  inline const int CTask::get_nRunningThreads () const
  {
    return m_nRunningThreads;
  }

  inline const STaskCounters CTask::get_taskCounters () const
  {
    return m_taskCounters;
  }

} // namespace TASK

#endif

---