mi32/mistatus.h

Go to the documentation of this file.

#ifndef  INC_MI32_MISTATUS_H
#define  INC_MI32_MISTATUS_H

#ifndef  INC_MI32_MISYSTEM_H
#include <mi32/misystem.h>
#endif

#ifndef  INC_MI32_CRITSEC_H
#include <mi32/critsec.h>
#endif

#ifndef  INC_MI32_MILIST_H
#include <mi32/milist.h>
#endif

#ifndef  INC_MI32_MTIMER_H
#include <mi32/mtimer.h>
#endif


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

class MISTATUSCONTEXT;

//===================================================================================================================

class CLASSLIBEXPORT MISTATUSMANAGER {
   public:

      class SAVERESTORE {
         public:
            SAVERESTORE (
               ) : m_pManager(MISTATUSMANAGER::GetActiveManager()) { }
            ~SAVERESTORE (
               ) { MISTATUSMANAGER::SetActiveManager(m_pManager); }
         private:
            #ifndef GENERATING_DOXYGEN_OUTPUT
            MISTATUSMANAGER *m_pManager;
            SAVERESTORE (const SAVERESTORE&);
            SAVERESTORE& operator= (const SAVERESTORE&);
            #endif
         };

      static MISTATUSMANAGER* GetActiveManager ();

      static MISTATUSMANAGER* SetActiveManager (
         MISTATUSMANAGER *manager
         );

      static void SetCreator (
         FastDelegate<MISTATUSMANAGER*()> DelegateCreateManager
         );

      MISTATUSMANAGER ();

      virtual ~MISTATUSMANAGER ();

      MTIMER& GetTimer (
         ) { return (m_Timer); }

      bool IsCancelled (
         );

      bool ReportTimeElapsed (
         );

      void ReportTimerValue (
         const MTIMER& timer
         ) { v_ReportTimerValue(timer); }

      void ResetCancelled (
         );

      void RestartTimer (
         ) { m_Timer.Clear(); m_Timer.Start(); }

      void SetAsActive (
         ) { SetActiveManager(this); }

      //  (Will become private when legacy wrappers are removed)
      void SetCancelEnabled (
         bool enabled
         );

   protected:
      typedef MILIST<MISTATUSCONTEXT*> CONTEXTLIST;

      class CLASSLIBEXPORT CONTEXT_PRIV {
         public:
            virtual ~CONTEXT_PRIV () = 0;
         };

      void ClearContextList (
         );

      const CONTEXTLIST& GetContextList (
         MITHREAD::CRITICALSECTION::LOCK& Lock     
         ) const;

      MISYSTEM::THREAD_ID GetCreatorThreadID (
         ) const { return (m_CreatorThreadID); }

      bool IsCancelSet (
         ) const { return (m_IsCancelled); }

      void ReportMessage (
         MISTATUSCONTEXT& context,
         const MISTRING& msgstr
         ) { v_ReportMessage(context,msgstr); }

      void SetCancelled (
         );

   private:
      #ifndef GENERATING_DOXYGEN_OUTPUT
      friend class MISTATUSCONTEXT;
      CONTEXTLIST m_ContextList;
      mutable MITHREAD::CRITICALSECTION m_ContextListSync;
      MISYSTEM::THREAD_ID m_CreatorThreadID;
      UINT32 m_CancelDisableCount;
      bool m_IsCancelled;
      MTIMER m_Timer;
      double m_LastElapsed;

      static MISTATUSMANAGER* CreateManager ();

      void ContextAttach (
         MISTATUSCONTEXT *pContext
         );

      void ContextDetach (
         MISTATUSCONTEXT *pContext
         );

      CONTEXT_PRIV* ContextPrivCreate (
         MISTATUSCONTEXT& Context
         ) { return (v_ContextPrivCreate(Context)); }

      void ReportBegin (
         MISTATUSCONTEXT& context,
         const MISTRING& msgstr
         ) { v_ReportBegin(context,msgstr); }

      void ReportEnd (
         MISTATUSCONTEXT& context,
         const MISTRING& msgstr,
         const MISTRING& timerstr
         ) { v_ReportEnd(context,msgstr,timerstr); }

      void ReportProgress (
         MISTATUSCONTEXT& context,
         double pctdone
         ) { v_ReportProgress(context,pctdone); }

      void UpdateUI (
         ) { v_UpdateUI(); }

      // Unimplemented.
      MISTATUSMANAGER (const MISTATUSMANAGER&);
      MISTATUSMANAGER& operator= (const MISTATUSMANAGER&);
      #endif   // GENERATING_DOXYGEN_OUTPUT


      virtual CONTEXT_PRIV* v_ContextPrivCreate (
         MISTATUSCONTEXT& Context
         );

      virtual bool v_IsCancelled (
         );

      virtual void v_ReportBegin (
         MISTATUSCONTEXT& context,
         const MISTRING& msgstr
         );

      virtual void v_ReportEnd (
         MISTATUSCONTEXT& context,
         const MISTRING& msgstr,
         const MISTRING& timerstr
         );

      virtual void v_ReportMessage (
         MISTATUSCONTEXT& context,
         const MISTRING& msgstr
         );

      virtual void v_ReportProgress (
         MISTATUSCONTEXT& context,
         double pctdone
         );

      virtual void v_ReportTimerValue (
         const MTIMER& timer
         );

      virtual void v_ResetCancelled (
         );

      virtual void v_SetCancelEnabled (
         bool enabled
         );

      virtual void v_UpdateUI (
         );

   };

//===================================================================================================================

class CLASSLIBEXPORT MISTATUSLOGGER : public MISTATUSMANAGER {
   public:

      MISTATUSLOGGER ();

      virtual ~MISTATUSLOGGER ();

      void SetLogDisabled (
         ) { ++m_LogDisableCount; }

      void SetLogEnabled (
         ) { if (m_LogDisableCount) --m_LogDisableCount; }

   protected:

      virtual void v_ReportBegin (
         MISTATUSCONTEXT& context,
         const MISTRING& msgstr
         );

      virtual void v_ReportEnd (
         MISTATUSCONTEXT& context,
         const MISTRING& msgstr,
         const MISTRING& timerstr
         );

      virtual void v_ReportMessage (
         MISTATUSCONTEXT& context,
         const MISTRING& msgstr
         );

   private:
      #ifndef GENERATING_DOXYGEN_OUTPUT
      UINT32 m_LogDisableCount;
      // Unimplemented.
      MISTATUSLOGGER (const MISTATUSLOGGER&);
      MISTATUSLOGGER& operator= (const MISTATUSLOGGER&);
      #endif   // GENERATING_DOXYGEN_OUTPUT
   };

//===================================================================================================================

class CLASSLIBEXPORT MISTATUSCONTEXT {
   public:

      MISTATUSCONTEXT ();

      MISTATUSCONTEXT (
         MISTATUSMANAGER *pStatusMgr,     
         const MISTRING& taskstr,         
         bool AllowCancel = true          
         );

      MISTATUSCONTEXT (
         const MISTRING& taskstr,         
         bool AllowCancel = true,         
         bool CreateMgrIfNoActive = false 
         );

      ~MISTATUSCONTEXT (
         );

      ERRVALUE Create (
         MISTATUSMANAGER *pStatusMgr,     
         const MISTRING& taskstr,         
         bool AllowCancel = true          
         ) { return (CreateLow(pStatusMgr,taskstr,AllowCancel,false)); }

      ERRVALUE Create (
         const MISTRING& taskstr,         
         bool AllowCancel = true,         
         bool CreateMgrIfNoActive = false 
         ) { return (CreateLow(MISTATUSMANAGER::GetActiveManager(),taskstr,AllowCancel,CreateMgrIfNoActive)); }

   #ifndef GENERATING_DOXYGEN_OUTPUT
      void DetachMgr (
         ) { m_pStatusMgr = 0; m_IsCancelled = true; }
   #endif

      MISTATUSMANAGER* GetManager (
         ) const { return (m_pStatusMgr); }

      MISTATUSMANAGER::CONTEXT_PRIV* GetPriv (
         ) const { return (m_pPriv); }

      bool HasManager (
         ) const { return (m_pStatusMgr != 0); }

      bool IsCancelled (
         ) { return (m_IsCancelled || (m_IsCancelled = (m_pStatusMgr != 0 && m_pStatusMgr->IsCancelled()))); }

      ERRVALUE ReportMessage (
         const MISTRING& msgstr
         ) { if (m_pStatusMgr != 0) m_pStatusMgr->ReportMessage(*this,msgstr); return (TestCancelled()); }

      ERRVALUE ReportProgress (
         double pctdone = -1              
         ) { ReportProgressNoCancel(pctdone); return (TestCancelled()); }

      void ReportProgressNoCancel (
         double pctdone = -1              
         ) { if (m_pStatusMgr != 0) m_pStatusMgr->ReportProgress(*this,pctdone); }

      ERRVALUE ReportProgressBegin (
         UINT32 NumSteps                  
         );

      ERRVALUE ReportProgressIncrement (
         INT32 IncSteps = 1               
         ) { ReportProgressIncrementNoCancel(IncSteps); return (TestCancelled()); }

      void ReportProgressIncrementNoCancel (
         INT32 IncSteps = 1               
         ) { m_CurStep += IncSteps; if (m_pStatusMgr != 0) m_pStatusMgr->ReportProgress(*this,100.0*m_CurStep/m_NumSteps); }

      void SetCancelled (
         ) { m_IsCancelled = true; }

   private:
      #ifndef GENERATING_DOXYGEN_OUTPUT
      MISTATUSMANAGER *m_pStatusMgr;
      MISTATUSMANAGER::CONTEXT_PRIV *m_pPriv;
      MISTRING m_taskstr;
      MTIMER m_Timer;
      UINT32 m_NumSteps;
      INT32 m_CurStep;
      bool m_AllowCancel;
      bool m_OwnStatusMgr;
      bool m_IsCancelled;

      ERRVALUE CreateLow (MISTATUSMANAGER *pStatusMgr, const MISTRING& taskstr, bool AllowCancel, bool CreateMgrIfNoneSet);
      void Initialize (bool CreateMgrIfNoneSet);
      ERRVALUE TestCancelled (
         ) { return ((m_AllowCancel && IsCancelled()) ? EUserCancel : 0); }

      // Unimplemented.
      MISTATUSCONTEXT (const MISTATUSCONTEXT&);
      MISTATUSCONTEXT& operator= (const MISTATUSCONTEXT&);
      #endif   // GENERATING_DOXYGEN_OUTPUT
   };

//===================================================================================================================

#undef   CLASSLIBEXPORT

#endif   // INC_MI32_MISTATUS_H

---