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