ReactOS  0.4.14-dev-608-gd495a4f
atlsimpcoll.h
Go to the documentation of this file.
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>
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>
28 {
29 public:
30  static bool IsEqual(const T&, const T&)
31  {
33  return false;
34  }
35 };
36 
37 template <typename T, typename TEqual = CSimpleArrayEqualHelper<T> >
39 {
40 public:
42 
44  {
45  }
46 
49  {
50  *this = src;
51  }
52 
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(static_cast<void *>(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
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 
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(static_cast<void *>(&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 
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(static_cast<void *>(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 
240  {
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 
256  };
257 
258 };
259 
260 template <typename TKey, typename TVal>
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>
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> >
296 {
297 public:
298  typedef TKey _ArrayKeyType;
299  typedef TVal _ArrayElementType;
300 
302  {
303  }
304 
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 
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 
442  {
443  key = pair.key;
444  val = pair.val;
445  return *this;
446  }
447  };
448 
450 };
451 
452 }
453 
454 #endif
#define realloc
Definition: debug_ros.c:6
#define memmove(s1, s2, n)
Definition: mkisofs.h:881
#define TRUE
Definition: types.h:120
const T * GetData() const
Definition: atlsimpcoll.h:99
BOOL Add(const T &t)
Definition: atlsimpcoll.h:58
BOOL SetAtIndex(int nIndex, const TKey &key, const TVal &val)
Definition: atlsimpcoll.h:412
#define ATLASSERT(x)
Definition: CComVariant.cpp:9
TVal _ArrayElementType
Definition: atlsimpcoll.h:299
#define free
Definition: debug_ros.c:5
BOOL SetAt(const TKey &key, const TVal &val)
Definition: atlsimpcoll.h:402
GLdouble GLdouble t
Definition: gl.h:2047
T & operator[](int nIndex)
Definition: atlsimpcoll.h:163
int FindVal(const TVal &val) const
Definition: atlsimpcoll.h:328
BOOL Remove(const T &t)
Definition: atlsimpcoll.h:109
CSimpleArray< T, TEqual > & operator=(const CSimpleArray< T, TEqual > &src)
Definition: atlsimpcoll.h:175
int GetSize() const
Definition: atlsimpcoll.h:104
static bool IsEqualValue(const TVal &v1, const TVal &v2)
Definition: atlsimpcoll.h:286
#define T
Definition: mbstring.h:31
const TKey & GetKeyAt(int nIndex) const
Definition: atlsimpcoll.h:347
unsigned int BOOL
Definition: ntddk_ex.h:94
BOOL Remove(const TKey &key)
Definition: atlsimpcoll.h:378
static PVOID ptr
Definition: dispmode.c:27
int GetSize() const
Definition: atlsimpcoll.h:353
smooth NULL
Definition: ftsmooth.c:416
static bool IsEqualKey(const TKey &k1, const TKey &k2)
Definition: atlsimpcoll.h:280
GLuint GLfloat * val
Definition: glext.h:7180
Pair(const Pair &pair)
Definition: atlsimpcoll.h:437
__kernel_size_t size_t
Definition: linux.h:237
Definition: rosdlgs.h:5
Pair(const TKey &k, const TVal &v)
Definition: atlsimpcoll.h:433
static bool IsEqualKey(const TKey &k1, const TKey &k2)
Definition: atlsimpcoll.h:264
struct _pair * pair
TKey ReverseLookup(const TVal &val) const
Definition: atlsimpcoll.h:394
TVal Lookup(const TKey &key) const
Definition: atlsimpcoll.h:370
HKEY key
Definition: reg.c:42
CSimpleArray(const CSimpleArray< T, TEqual > &src)
Definition: atlsimpcoll.h:47
BOOL Add(const TKey &key, const TVal &val)
Definition: atlsimpcoll.h:309
TKey & GetKeyAt(int nIndex)
Definition: atlsimpcoll.h:341
GLenum src
Definition: glext.h:6340
Pair & operator=(const Pair &pair)
Definition: atlsimpcoll.h:441
GLfloat GLfloat GLfloat v2
Definition: glext.h:6063
const GLdouble * v
Definition: gl.h:2040
const T & operator[](int nIndex) const
Definition: atlsimpcoll.h:169
Definition: _pair.h:47
static bool IsEqual(const T &, const T &)
Definition: atlsimpcoll.h:30
static const int c_nGrow
Definition: atlsimpcoll.h:218
void DestructItem(int nIndex)
Definition: atlsimpcoll.h:232
CSimpleArray< Pair, CSimpleArrayEqualHelperFalse< Pair > > m_Pairs
Definition: atlsimpcoll.h:449
const TVal & GetValueAt(int nIndex) const
Definition: atlsimpcoll.h:364
BOOL SetAtIndex(int nIndex, const T &t)
Definition: atlsimpcoll.h:152
TVal & GetValueAt(int nIndex)
Definition: atlsimpcoll.h:358
static bool IsEqualValue(const TVal &v1, const TVal &v2)
Definition: atlsimpcoll.h:269
GLfloat GLfloat p
Definition: glext.h:8902
int FindKey(const TKey &key) const
Definition: atlsimpcoll.h:315
GLfloat GLfloat v1
Definition: glext.h:6062
BOOL RemoveAt(int nIndex)
Definition: atlsimpcoll.h:389
int k
Definition: mpi.c:3369
BOOL RemoveAt(int nIndex)
Definition: atlsimpcoll.h:132
void ConstructItemInPlace(int nIndex, const T &src)
Definition: atlsimpcoll.h:226
static bool IsEqual(const T &t1, const T &t2)
Definition: atlsimpcoll.h:19
Definition: path.c:41
int Find(const T &t) const
Definition: atlsimpcoll.h:82