mi32/mithread.h

Go to the documentation of this file.

#ifndef  INC_MI32_MITHREAD_H
#define  INC_MI32_MITHREAD_H

#ifndef  INC_MI32_DELEGATE_H
   #include <mi32/delegate.h>
#endif

#ifndef  INC_MI32_ERRHANDLER_H
   #include <mi32/errhandler.h>     // Needed for ERRORSTATE define
#endif

#ifdef MISYSTEMDLL
   #define CLASSLIBEXPORT MI_DLLCLASSEXPORT
#else
   #define CLASSLIBEXPORT MI_DLLCLASSIMPORT
#endif

#if defined(WIN32) && defined(AddJob)
#undef AddJob
#endif


#ifndef GENERATING_DOXYGEN_OUTPUT
// Forward declarations.
class MISTATUSMANAGER;
namespace MITHREAD {
   class JOB;
   class QUEUE;
   class POOL;
   struct POOLITEM;
   class POOLJOB;
   struct QUEUEITEM;
   struct QUEUEITEMLIST;
   }
#endif


namespace MITHREAD {

typedef UINT32 ID;

typedef fastdelegate::FastDelegate<void(MITHREAD::ID)> DELEGATE_VOID_ID;

class CLASSLIBEXPORT WORKER {
   public:
      explicit WORKER (
         MISTATUSMANAGER* DftManager = 0,    
         const char* DebugName = 0           
         );

      ~WORKER (
         );

      void CancelJob (
         );    

      void ExecuteJob (
         JOB& Job
         );

      bool IsCanceling (
         ) const;

   #ifndef GENERATING_DOXYGEN_OUTPUT
      class PRIV;
      PRIV* GetPriv () { return (m_pPriv); }
   #endif

   private:
      #ifndef GENERATING_DOXYGEN_OUTPUT
      WORKER (const WORKER&);
      WORKER& operator=(const WORKER&);
   
      PRIV* m_pPriv;
      friend class JOB;
      friend class POOL;
      #endif // GENERATING_DOXYGEN_OUTPUT
   };


class CLASSLIBEXPORT POOL {
   public:

      POOL (
         UINT32 NumPoolThreads = 0,          
         MISTATUSMANAGER* DftManager = 0,    
         bool IncludeLogicalCores = false
         );
      
      ~POOL (
         );
         
      ID AddQueue (
         QUEUE& Queue,
         bool AddToFront = false       
         );

      ID AddQueue (
         QUEUE& Queue,
         JOB& Job                         


         );

      void CancelJob (
         ID JobID                   
         );
         
      void CancelQueue (
         ID QueueID                    
         );
         
      UINT32 GetNumActiveThreads () const;
   
      void SetDelegateOnCompletion (
         DELEGATE_VOID_NOPARMS OnCompletion
         );
         
      void StartQueuedJobs ();

      void SuspendQueuedJobs ();
         
      void WaitForCompletion ();
         
   private:
      #ifndef GENERATING_DOXYGEN_OUTPUT
      POOL (const POOL&);
      POOL& operator=(const POOL&);
   
      class PRIV;
      PRIV* m_pPriv;
      friend class JOB;
      friend class POOLJOB;
      friend struct POOLITEM;
      friend class QUEUE;
      friend class WORKER::PRIV;
      #endif // GENERATING_DOXYGEN_OUTPUT
   };


class CLASSLIBEXPORT QUEUE {
   public:
      
      enum FLAGS {
         FLAG_Default =                0x0000,           
         FLAG_Synchronized =           0x0001            
         };
         
      explicit QUEUE (
         FLAGS flags = FLAG_Default
         );

      QUEUE (
         const QUEUE& rhs
         );
      
      ~QUEUE (
         );

      QUEUE& operator=(
         const QUEUE& rhs
         );
   
      ID AddJob (
         JOB& Job,
         bool AddToFront = false       
         );
         
      ID AddQueue (
         QUEUE& Queue,                 
         bool AddToFront = false       
         );
   
      FLAGS GetFlags (
         ) const;

      ID GetID (
         ) const;

      bool IsEmpty (
         ) const;
         
      void SetDelegateOnCompletion (
         DELEGATE_VOID_ID delegate
         );
         
   private:
      #ifndef GENERATING_DOXYGEN_OUTPUT
      class PRIV;
      PRIV* m_pPriv;
      friend class JOB;
      friend struct QUEUEITEM;
      friend struct QUEUEITEMLIST;
      friend class POOL::PRIV;
      #endif // GENERATING_DOXYGEN_OUTPUT
   };

class CLASSLIBEXPORT JOB {
   public:
      enum FLAGS {
         FLAG_Default =                0x0000,  
         FLAG_Synchronized =           0x0001,  
         FLAG_DeleteWhenCompleted =    0x0002,  
         FLAG_StopIfError =            0x0004   
         };
   
      explicit JOB (
         FLAGS flags = FLAG_Default,
         MISTATUSMANAGER* Manager = 0                    
         );

      virtual ~JOB (
         ) = 0;

      const ERRORSTATE& GetErrorState (
         ) const { return (m_ErrorState); }

      FLAGS GetFlags (
         ) const { return (m_JobFlags); }

      ID GetID (
         ) const { return (m_ID); }

      void SetDelegateOnCancelBeforeRun (
         DELEGATE_VOID_ID delegate
         ) { m_DelegateOnCancelBeforeRun = delegate; }
         
      void SetDelegateOnCompletion (
         DELEGATE_VOID_ID delegate
         ) { m_DelegateOnCompletion = delegate; }
         
   protected:

      WORKER* GetWorker (
         ) { return (m_Worker); } 

      ERRVALUE CheckCancel (
         );
         
   private:

      virtual void v_OnCancelBeforeRun ();
      
      virtual ERRVALUE v_RunJob () = 0;

      #ifndef GENERATING_DOXYGEN_OUTPUT
      JOB (const JOB&);
      JOB& operator=(const JOB&);

      void NotifyCancelBeforeRun ();
      ERRVALUE RunJob ();
      
      ID m_ID;
      FLAGS m_JobFlags;
      ERRORSTATE m_ErrorState;
      DELEGATE_VOID_ID m_DelegateOnCancelBeforeRun;
      DELEGATE_VOID_ID m_DelegateOnCompletion;
      QUEUE::PRIV* m_ParentQueuePriv;
      WORKER* m_Worker;
      MISTATUSMANAGER* m_pManager;
      
      friend struct QUEUEITEM;
      friend class QUEUE::PRIV;
      friend class WORKER::PRIV;
      friend class POOLJOB;
      friend class POOL::PRIV;
      #endif // GENERATING_DOXYGEN_OUTPUT
   };


class CLASSLIBEXPORT WORKER_DETACHED {
   protected:
      WORKER_DETACHED ();
      virtual ~WORKER_DETACHED () = 0;
      
      void ExecuteThread (
         MISTATUSMANAGER* manager = 0,    
         const char* DebugName = 0     
         );
      
   private:
      virtual void v_ExecuteThread () = 0;
      
      #ifndef GENERATING_DOXYGEN_OUTPUT
      MISTATUSMANAGER* m_pManager;
      const char* m_pDebugName;
      #if defined(WIN32)
         friend UINT32 __stdcall MyThreadFunc (void *vpwd);
      #else
         friend void* MyThreadFunc (void *vpwd);
      #endif
      #endif // GENERATING_DOXYGEN_OUTPUT
   };

}  // End of MITHREAD namespace

#ifndef GENERATING_DOXYGEN_OUTPUT
DEFINE_ENUM_OP_BITWISE(MITHREAD::JOB::FLAGS)
DEFINE_ENUM_OP_BITWISE(MITHREAD::QUEUE::FLAGS)
#endif // GENERATING_DOXYGEN_OUTPUT

#undef   CLASSLIBEXPORT

#endif   

---