home *** CD-ROM | disk | FTP | other *** search
/ QBasic & Borland Pascal & C / Delphi5.iso / C / BC_502 / MFCINC.PAK / AFXMT.H < prev    next >
Encoding:
C/C++ Source or Header  |  1997-05-06  |  5.4 KB  |  256 lines

  1. // This is a part of the Microsoft Foundation Classes C++ library.
  2. // Copyright (C) 1992-1995 Microsoft Corporation
  3. // All rights reserved.
  4. //
  5. // This source code is only intended as a supplement to the
  6. // Microsoft Foundation Classes Reference and related
  7. // electronic documentation provided with the library.
  8. // See these sources for detailed information regarding the
  9. // Microsoft Foundation Classes product.
  10.  
  11. #ifndef __AFXMT_H__
  12. #define __AFXMT_H__
  13.  
  14. #ifdef _MAC
  15.     #error Multithreaded classes not supported in this library variant.
  16. #endif
  17.  
  18. #ifndef __AFX_H__
  19.     #include <afx.h>
  20. #endif
  21.  
  22. #ifdef _AFX_MINREBUILD
  23. #pragma component(minrebuild, off)
  24. #endif
  25. #ifndef _AFX_FULLTYPEINFO
  26. #pragma component(mintypeinfo, on)
  27. #endif
  28.  
  29. #ifdef _AFX_PACKING
  30. #pragma pack(push, _AFX_PACKING)
  31. #endif
  32.  
  33. /////////////////////////////////////////////////////////////////////////////
  34. // AFXMT - MFC Multithreaded Extensions (Syncronization Objects)
  35.  
  36. // Classes declared in this file
  37.  
  38. //CObject
  39.     class CSyncObject;
  40.         class CSemaphore;
  41.         class CMutex;
  42.         class CEvent;
  43.         class CCriticalSection;
  44.  
  45. class CSingleLock;
  46. class CMultiLock;
  47.  
  48. #undef AFX_DATA
  49. #define AFX_DATA AFX_CORE_DATA
  50.  
  51. /////////////////////////////////////////////////////////////////////////////
  52. // Basic synchronization object
  53.  
  54. class CSyncObject : public CObject
  55. {
  56.     DECLARE_DYNAMIC(CSyncObject)
  57.  
  58. // Constructor
  59. public:
  60.     CSyncObject(LPCTSTR pstrName);
  61.  
  62. // Attributes
  63. public:
  64.     operator HANDLE() const;
  65.     HANDLE  m_hObject;
  66.  
  67. // Operations
  68.     virtual BOOL Lock(DWORD dwTimeout = INFINITE);
  69.     virtual BOOL Unlock() = 0;
  70.     virtual BOOL Unlock(LONG /* lCount */, LPLONG /* lpPrevCount=NULL */)
  71.         { return TRUE; }
  72.  
  73. // Implementation
  74. public:
  75.     virtual ~CSyncObject();
  76. #ifdef _DEBUG
  77.     CString m_strName;
  78.     virtual void AssertValid() const;
  79.     virtual void Dump(CDumpContext& dc) const;
  80. #endif
  81.     friend class CSingleLock;
  82.     friend class CMultiLock;
  83. };
  84.  
  85. /////////////////////////////////////////////////////////////////////////////
  86. // CSemaphore
  87.  
  88. class CSemaphore : public CSyncObject
  89. {
  90.     DECLARE_DYNAMIC(CSemaphore)
  91.  
  92. // Constructor
  93. public:
  94.     CSemaphore(LONG lInitialCount = 1, LONG lMaxCount = 1,
  95.         LPCTSTR pstrName=NULL, LPSECURITY_ATTRIBUTES lpsaAttributes = NULL);
  96.  
  97. // Implementation
  98. public:
  99.     virtual ~CSemaphore();
  100.     virtual BOOL Unlock();
  101.     virtual BOOL Unlock(LONG lCount, LPLONG lprevCount = NULL);
  102. };
  103.  
  104. /////////////////////////////////////////////////////////////////////////////
  105. // CMutex
  106.  
  107. class CMutex : public CSyncObject
  108. {
  109.     DECLARE_DYNAMIC(CMutex)
  110.  
  111. // Constructor
  112. public:
  113.     CMutex(BOOL bInitiallyOwn = FALSE, LPCTSTR lpszName = NULL,
  114.         LPSECURITY_ATTRIBUTES lpsaAttribute = NULL);
  115.  
  116. // Implementation
  117. public:
  118.     virtual ~CMutex();
  119.     BOOL Unlock();
  120. };
  121.  
  122. /////////////////////////////////////////////////////////////////////////////
  123. // CEvent
  124.  
  125. class CEvent : public CSyncObject
  126. {
  127.     DECLARE_DYNAMIC(CEvent)
  128.  
  129. // Constructor
  130. public:
  131.     CEvent(BOOL bInitiallyOwn = FALSE, BOOL bManualReset = FALSE,
  132.         LPCTSTR lpszNAme = NULL, LPSECURITY_ATTRIBUTES lpsaAttribute = NULL);
  133.  
  134. // Operations
  135. public:
  136.     BOOL SetEvent();
  137.     BOOL PulseEvent();
  138.     BOOL ResetEvent();
  139.     BOOL Unlock();
  140.  
  141. // Implementation
  142. public:
  143.     virtual ~CEvent();
  144. };
  145.  
  146. /////////////////////////////////////////////////////////////////////////////
  147. // CCriticalSection
  148.  
  149. class CCriticalSection : public CSyncObject
  150. {
  151.     DECLARE_DYNAMIC(CCriticalSection)
  152.  
  153. // Constructor
  154. public:
  155.     CCriticalSection();
  156.  
  157. // Attributes
  158. public:
  159.     operator CRITICAL_SECTION*();
  160.     CRITICAL_SECTION m_sect;
  161.  
  162. // Operations
  163. public:
  164.     BOOL Unlock();
  165.     BOOL Lock();
  166.     BOOL Lock(DWORD dwTimeout);
  167.  
  168. // Implementation
  169. public:
  170.     virtual ~CCriticalSection();
  171. };
  172.  
  173. /////////////////////////////////////////////////////////////////////////////
  174. // CSingleLock
  175.  
  176. class CSingleLock
  177. {
  178. // Constructors
  179. public:
  180.     CSingleLock(CSyncObject* pObject, BOOL bInitialLock = FALSE);
  181.  
  182. // Operations
  183. public:
  184.     BOOL Lock(DWORD dwTimeOut = INFINITE);
  185.     BOOL Unlock();
  186.     BOOL Unlock(LONG lCount, LPLONG lPrevCount = NULL);
  187.     BOOL IsLocked();
  188.  
  189. // Implementation
  190. public:
  191.     ~CSingleLock();
  192.  
  193. protected:
  194.     CSyncObject* m_pObject;
  195.     HANDLE  m_hObject;
  196.     BOOL    m_bAcquired;
  197. };
  198.  
  199. /////////////////////////////////////////////////////////////////////////////
  200. // CMultiLock
  201.  
  202. class CMultiLock
  203. {
  204. // Constructor
  205. public:
  206.     CMultiLock(CSyncObject* ppObjects[], DWORD dwCount, BOOL bInitialLock = FALSE);
  207.  
  208. // Operations
  209. public:
  210.     DWORD Lock(DWORD dwTimeOut = INFINITE, BOOL bWaitForAll = TRUE,
  211.         DWORD dwWakeMask = 0);
  212.     BOOL Unlock();
  213.     BOOL Unlock(LONG lCount, LPLONG lPrevCount = NULL);
  214.     BOOL IsLocked(DWORD dwItem);
  215.  
  216. // Implementation
  217. public:
  218.     ~CMultiLock();
  219.  
  220. protected:
  221.     HANDLE  m_hPreallocated[8];
  222.     BOOL    m_bPreallocated[8];
  223.  
  224.     CSyncObject* const * m_ppObjectArray;
  225.     HANDLE* m_pHandleArray;
  226.     BOOL*   m_bLockedArray;
  227.     DWORD   m_dwCount;
  228. };
  229.  
  230. /////////////////////////////////////////////////////////////////////////////
  231. // Inline function declarations
  232.  
  233. #ifdef _AFX_PACKING
  234. #pragma pack(pop)
  235. #endif
  236.  
  237. #ifdef _AFX_ENABLE_INLINES
  238. #define _AFXMT_INLINE inline
  239. #include <afxmt.inl>
  240. #undef _AFXMT_INLINE
  241. #endif
  242.  
  243. #undef AFX_DATA
  244. #define AFX_DATA
  245.  
  246. #ifdef _AFX_MINREBUILD
  247. #pragma component(minrebuild, on)
  248. #endif
  249. #ifndef _AFX_FULLTYPEINFO
  250. #pragma component(mintypeinfo, off)
  251. #endif
  252.  
  253. #endif  // __AFXMT_H__
  254.  
  255. /////////////////////////////////////////////////////////////////////////////
  256.