Git conversion: Make reactos the root directory, move rosapps, rostests, wallpapers...
[reactos.git] / sdk / lib / atl / atlsimpcoll.h
1 // PROJECT: ReactOS ATL Simple Collection
2 // LICENSE: Public Domain
3 // PURPOSE: Provides compatibility to Microsoft ATL
4 // PROGRAMMERS: Katayama Hirofumi MZ (katayama.hirofumi.mz@gmail.com)
5
6 #ifndef __ATLSIMPCOLL_H__
7 #define __ATLSIMPCOLL_H__
8
9 #pragma once
10
11 #include "atlcore.h" // for ATL Core
12
13 namespace ATL
14 {
15 template <typename T>
16 class CSimpleArrayEqualHelper
17 {
18 public:
19 static bool IsEqual(const T& t1, const T& t2)
20 {
21 return t1 == t2;
22 }
23 };
24
25 // This class exists for the element types of no comparison.
26 template <typename T>
27 class CSimpleArrayEqualHelperFalse
28 {
29 public:
30 static bool IsEqual(const T&, const T&)
31 {
32 ATLASSERT(FALSE);
33 return false;
34 }
35 };
36
37 template <typename T, typename TEqual = CSimpleArrayEqualHelper<T> >
38 class CSimpleArray
39 {
40 public:
41 typedef T _ArrayElementType;
42
43 CSimpleArray() : m_pData(NULL), m_nCount(0), m_nCapacity(0)
44 {
45 }
46
47 CSimpleArray(const CSimpleArray<T, TEqual>& src) :
48 m_pData(NULL), m_nCount(0), m_nCapacity(0)
49 {
50 *this = src;
51 }
52
53 ~CSimpleArray()
54 {
55 RemoveAll();
56 }
57
58 BOOL Add(const T& t)
59 {
60 // is the capacity enough?
61 if (m_nCapacity < m_nCount + 1)
62 {
63 // allocate extra capacity for optimization
64 const int nNewCapacity = (m_nCount + 1) + c_nGrow;
65 T *pNewData = (T *)realloc(m_pData, nNewCapacity * sizeof(T));
66 if (pNewData == NULL)
67 return FALSE; // failure
68
69 m_pData = pNewData;
70 m_nCapacity = nNewCapacity;
71 }
72
73 // call constructor
74 ConstructItemInPlace(m_nCount, t);
75
76 // increment
77 ++m_nCount;
78
79 return TRUE;
80 }
81
82 int Find(const T& t) const
83 {
84 for (int nIndex = 0; nIndex < m_nCount; ++nIndex)
85 {
86 if (TEqual::IsEqual(m_pData[nIndex], t))
87 {
88 return nIndex; // success
89 }
90 }
91 return -1; // failure
92 }
93
94 T* GetData()
95 {
96 return m_pData;
97 }
98
99 const T* GetData() const
100 {
101 return m_pData;
102 }
103
104 int GetSize() const
105 {
106 return m_nCount;
107 }
108
109 BOOL Remove(const T& t)
110 {
111 return RemoveAt(Find(t));
112 }
113
114 void RemoveAll()
115 {
116 if (m_pData)
117 {
118 // call destructor
119 const int nCount = m_nCount;
120 for (int nIndex = 0; nIndex < nCount; ++nIndex)
121 {
122 DestructItem(nIndex);
123 }
124
125 free(m_pData);
126 m_pData = NULL;
127 }
128 m_nCount = 0;
129 m_nCapacity = 0;
130 }
131
132 BOOL RemoveAt(int nIndex)
133 {
134 // boundary check
135 if (nIndex < 0 || m_nCount <= nIndex)
136 return FALSE; // failure
137
138 // call destructor
139 DestructItem(nIndex);
140
141 // move range [nIndex + 1, m_nCount) to nIndex
142 const int nRightCount = m_nCount - (nIndex + 1);
143 const int nRightSize = nRightCount * sizeof(T);
144 memmove(&m_pData[nIndex], &m_pData[nIndex + 1], nRightSize);
145
146 // decrement
147 --m_nCount;
148
149 return TRUE;
150 }
151
152 BOOL SetAtIndex(int nIndex, const T& t)
153 {
154 // boundary check
155 if (nIndex < 0 || m_nCount <= nIndex)
156 return FALSE; // failure
157
158 // store it
159 m_pData[nIndex] = t;
160 return TRUE;
161 }
162
163 T& operator[](int nIndex)
164 {
165 ATLASSERT(0 <= nIndex && nIndex < m_nCount);
166 return m_pData[nIndex];
167 }
168
169 const T& operator[](int nIndex) const
170 {
171 ATLASSERT(0 <= nIndex && nIndex < m_nCount);
172 return m_pData[nIndex];
173 }
174
175 CSimpleArray<T, TEqual>& operator=(const CSimpleArray<T, TEqual>& src)
176 {
177 // don't copy if two objects are same
178 if (this == &src)
179 return *this;
180
181 if (src.GetSize() != GetSize())
182 {
183 RemoveAll();
184
185 int nNewCount = src.GetSize();
186
187 T *pNewData = (T *)realloc(m_pData, nNewCount * sizeof(T));
188 ATLASSERT(pNewData);
189 if (pNewData == NULL)
190 return *this; // failure
191
192 // store new
193 m_pData = pNewData;
194 m_nCount = nNewCount;
195 m_nCapacity = nNewCount;
196 }
197 else
198 {
199 for (int nIndex = 0; nIndex < m_nCount; ++nIndex)
200 {
201 DestructItem(nIndex);
202 }
203 }
204
205 ATLASSERT(GetSize() == src.GetSize());
206 for (int nIndex = 0; nIndex < src.GetSize(); ++nIndex)
207 {
208 ConstructItemInPlace(nIndex, src[nIndex]);
209 }
210
211 return *this;
212 }
213
214 protected:
215 T * m_pData; // malloc'ed
216 int m_nCount; // # of items of type T
217 int m_nCapacity; // for optimization
218 static const int c_nGrow = 8; // for optimization
219
220 // NOTE: Range m_pData[0] .. m_pData[m_nCapacity - 1] are accessible.
221 // NOTE: Range [0, m_nCount) are constructed.
222 // NOTE: Range [m_nCount, m_nCapacity) are not constructed.
223 // NOTE: 0 <= m_nCount && m_nCount <= m_nCapacity.
224
225 // call constructor at nIndex
226 void ConstructItemInPlace(int nIndex, const T& src)
227 {
228 new(&m_pData[nIndex]) ConstructImpl(src);
229 }
230
231 // call destructor at nIndex
232 void DestructItem(int nIndex)
233 {
234 m_pData[nIndex].~T();
235 }
236
237 private:
238
239 struct ConstructImpl
240 {
241 ConstructImpl(const T& obj)
242 :m_ConstructHelper(obj)
243 {
244 }
245
246 static void *operator new(size_t, void *ptr)
247 {
248 return ptr;
249 }
250
251 static void operator delete(void *p, void* )
252 {
253 }
254
255 T m_ConstructHelper;
256 };
257
258 };
259
260 template <typename TKey, typename TVal>
261 class CSimpleMapEqualHelper
262 {
263 public:
264 static bool IsEqualKey(const TKey& k1, const TKey& k2)
265 {
266 return k1 == k2;
267 }
268
269 static bool IsEqualValue(const TVal& v1, const TVal& v2)
270 {
271 return v1 == v2;
272 }
273 };
274
275 // This class exists for the keys and the values of no comparison.
276 template <typename TKey, typename TVal>
277 class CSimpleMapEqualHelperFalse
278 {
279 public:
280 static bool IsEqualKey(const TKey& k1, const TKey& k2)
281 {
282 ATLASSERT(FALSE);
283 return false;
284 }
285
286 static bool IsEqualValue(const TVal& v1, const TVal& v2)
287 {
288 ATLASSERT(FALSE);
289 return false;
290 }
291 };
292
293 template <typename TKey, typename TVal,
294 typename TEqual = CSimpleMapEqualHelper<TKey, TVal> >
295 class CSimpleMap
296 {
297 public:
298 typedef TKey _ArrayKeyType;
299 typedef TVal _ArrayElementType;
300
301 CSimpleMap()
302 {
303 }
304
305 ~CSimpleMap()
306 {
307 }
308
309 BOOL Add(const TKey& key, const TVal& val)
310 {
311 Pair pair(key, val);
312 return m_Pairs.Add(pair);
313 }
314
315 int FindKey(const TKey& key) const
316 {
317 const int nCount = GetSize();
318 for (int nIndex = 0; nIndex < nCount; ++nIndex)
319 {
320 if (TEqual::IsEqualKey(m_Pairs[nIndex].key, key))
321 {
322 return nIndex; // success
323 }
324 }
325 return -1; // failure
326 }
327
328 int FindVal(const TVal& val) const
329 {
330 const int nCount = GetSize();
331 for (int nIndex = 0; nIndex < nCount; ++nIndex)
332 {
333 if (TEqual::IsEqualValue(m_Pairs[nIndex].val, val))
334 {
335 return nIndex; // success
336 }
337 }
338 return -1; // failure
339 }
340
341 TKey& GetKeyAt(int nIndex)
342 {
343 ATLASSERT(0 <= nIndex && nIndex < GetSize());
344 return m_Pairs[nIndex].key;
345 }
346
347 const TKey& GetKeyAt(int nIndex) const
348 {
349 ATLASSERT(0 <= nIndex && nIndex < GetSize());
350 return m_Pairs[nIndex].key;
351 }
352
353 int GetSize() const
354 {
355 return m_Pairs.GetSize();
356 }
357
358 TVal& GetValueAt(int nIndex)
359 {
360 ATLASSERT(0 <= nIndex && nIndex < GetSize());
361 return m_Pairs[nIndex].val;
362 }
363
364 const TVal& GetValueAt(int nIndex) const
365 {
366 ATLASSERT(0 <= nIndex && nIndex < GetSize());
367 return m_Pairs[nIndex].val;
368 }
369
370 TVal Lookup(const TKey& key) const
371 {
372 int nIndex = FindKey(key);
373 if (nIndex < 0)
374 return TVal();
375 return m_Pairs[nIndex].val;
376 }
377
378 BOOL Remove(const TKey& key)
379 {
380 int nIndex = FindKey(key);
381 return RemoveAt(nIndex);
382 }
383
384 void RemoveAll()
385 {
386 m_Pairs.RemoveAll();
387 }
388
389 BOOL RemoveAt(int nIndex)
390 {
391 return m_Pairs.RemoveAt(nIndex);
392 }
393
394 TKey ReverseLookup(const TVal& val) const
395 {
396 int nIndex = FindVal(val);
397 if (nIndex < 0)
398 return TKey();
399 return m_Pairs[nIndex].key;
400 }
401
402 BOOL SetAt(const TKey& key, const TVal& val)
403 {
404 int nIndex = FindKey(key);
405 if (nIndex < 0)
406 return Add(key, val);
407
408 m_Pairs[nIndex].val = val;
409 return TRUE;
410 }
411
412 BOOL SetAtIndex(int nIndex, const TKey& key, const TVal& val)
413 {
414 // boundary check
415 if (nIndex < 0 || GetSize() <= nIndex)
416 return FALSE;
417
418 m_Pairs[nIndex].key = key;
419 m_Pairs[nIndex].val = val;
420 return TRUE;
421 }
422
423 protected:
424 struct Pair
425 {
426 TKey key;
427 TVal val;
428
429 Pair()
430 {
431 }
432
433 Pair(const TKey& k, const TVal& v) : key(k), val(v)
434 {
435 }
436
437 Pair(const Pair& pair) : key(pair.key), val(pair.val)
438 {
439 }
440
441 Pair& operator=(const Pair& pair)
442 {
443 key = pair.key;
444 val = pair.val;
445 return *this;
446 }
447 };
448
449 CSimpleArray<Pair, CSimpleArrayEqualHelperFalse<Pair> > m_Pairs;
450 };
451
452 }
453
454 #endif