Statistics
| Revision:

root / trunk / install / launcher / izpack-launcher-1.3_linux / src / wx / include / wx / arrimpl.cpp @ 6834

History | View | Annotate | Download (8.55 KB)

1
///////////////////////////////////////////////////////////////////////////////
2
// Name:        wx/arrimpl.cpp
3
// Purpose:     helper file for implementation of dynamic lists
4
// Author:      Vadim Zeitlin
5
// Modified by:
6
// Created:     16.10.97
7
// RCS-ID:      $Id: arrimpl.cpp 6834 2006-08-24 08:23:24Z jmvivo $
8
// Copyright:   (c) 1997 Vadim Zeitlin <zeitlin@dptmaths.ens-cachan.fr>
9
// Licence:     wxWindows license
10
///////////////////////////////////////////////////////////////////////////////
11

    
12
/*****************************************************************************
13
 * Purpose: implements methods of "template" class declared in               *
14
 *          DECLARE_OBJARRAY macro and which couldn't be implemented inline  *
15
 *          (because they need the full definition of type T in scope)       *
16
 *                                                                           *
17
 * Usage:   1) #include dynarray.h                                           *
18
 *          2) WX_DECLARE_OBJARRAY                                           *
19
 *          3) #include arrimpl.cpp                                          *
20
 *          4) WX_DEFINE_OBJARRAY                                            *
21
 *****************************************************************************/
22

    
23
// needed to resolve the conflict between global T and macro parameter T
24

    
25
// VC++ can't cope with string concatenation in Unicode mode
26
#if defined(wxUSE_UNICODE) && wxUSE_UNICODE
27
#define _WX_ERROR_REMOVE2(x)     wxT("bad index in ::RemoveAt()")
28
#else
29
#define _WX_ERROR_REMOVE2(x)     wxT("bad index in " #x "::RemoveAt()")
30
#endif
31

    
32
// macro implements remaining (not inline) methods of template list
33
// (it's private to this file)
34
#undef  _DEFINE_OBJARRAY
35
#define _DEFINE_OBJARRAY(T, name)                                             \
36
name::~name()                                                                 \
37
{                                                                             \
38
  Empty();                                                                    \
39
}                                                                             \
40
                                                                              \
41
void name::DoCopy(const name& src)                                            \
42
{                                                                             \
43
  for ( size_t ui = 0; ui < src.Count(); ui++ )                               \
44
    Add(src[ui]);                                                             \
45
}                                                                             \
46
                                                                              \
47
name& name::operator=(const name& src)                                        \
48
{                                                                             \
49
  Empty();                                                                    \
50
  DoCopy(src);                                                                \
51
                                                                              \
52
  return *this;                                                               \
53
}                                                                             \
54
                                                                              \
55
name::name(const name& src) : wxArrayPtrVoid()                                \
56
{                                                                             \
57
  DoCopy(src);                                                                \
58
}                                                                             \
59
                                                                              \
60
void name::DoEmpty()                                                          \
61
{                                                                             \
62
  for ( size_t ui = 0; ui < Count(); ui++ )                                   \
63
    delete (T*)wxBaseArrayPtrVoid::Item(ui);                                  \
64
}                                                                             \
65
                                                                              \
66
void name::RemoveAt(size_t uiIndex, size_t nRemove)                           \
67
{                                                                             \
68
  wxCHECK_RET( uiIndex < Count(), _WX_ERROR_REMOVE2(name) );                  \
69
                                                                              \
70
  for (size_t i = 0; i < nRemove; i++ )                                       \
71
    delete (T*)wxBaseArrayPtrVoid::Item(uiIndex + i);                         \
72
                                                                              \
73
  wxBaseArrayPtrVoid::RemoveAt(uiIndex, nRemove);                             \
74
}                                                                             \
75
                                                                              \
76
void name::Add(const T& item, size_t nInsert)                                 \
77
{                                                                             \
78
  if (nInsert == 0)                                                           \
79
    return;                                                                   \
80
  T* pItem = new T(item);                                                     \
81
  size_t nOldSize = GetCount();                                               \
82
  if ( pItem != NULL )                                                        \
83
    wxBaseArrayPtrVoid::Add(pItem, nInsert);                                  \
84
  for (size_t i = 1; i < nInsert; i++)                                        \
85
    wxBaseArrayPtrVoid::Item(nOldSize + i) = new T(item);                     \
86
}                                                                             \
87
                                                                              \
88
void name::Insert(const T& item, size_t uiIndex, size_t nInsert)              \
89
{                                                                             \
90
  if (nInsert == 0)                                                           \
91
    return;                                                                   \
92
  T* pItem = new T(item);                                                     \
93
  if ( pItem != NULL )                                                        \
94
    wxBaseArrayPtrVoid::Insert(pItem, uiIndex, nInsert);                      \
95
  for (size_t i = 1; i < nInsert; i++)                                        \
96
    wxBaseArrayPtrVoid::Item(uiIndex + i) = new T(item);                      \
97
}                                                                             \
98
                                                                              \
99
int name::Index(const T& Item, bool bFromEnd) const                           \
100
{                                                                             \
101
  if ( bFromEnd ) {                                                           \
102
    if ( Count() > 0 ) {                                                      \
103
      size_t ui = Count() - 1;                                                \
104
      do {                                                                    \
105
        if ( (T*)wxBaseArrayPtrVoid::Item(ui) == &Item )                      \
106
          return ui;                                                          \
107
        ui--;                                                                 \
108
      }                                                                       \
109
      while ( ui != 0 );                                                      \
110
    }                                                                         \
111
  }                                                                           \
112
  else {                                                                      \
113
    for( size_t ui = 0; ui < Count(); ui++ ) {                                \
114
      if( (T*)wxBaseArrayPtrVoid::Item(ui) == &Item )                         \
115
        return ui;                                                            \
116
    }                                                                         \
117
  }                                                                           \
118
                                                                              \
119
  return wxNOT_FOUND;                                                         \
120
}
121

    
122
// redefine the macro so that now it will generate the class implementation
123
// old value would provoke a compile-time error if this file is not included
124
#undef  WX_DEFINE_OBJARRAY
125
#define WX_DEFINE_OBJARRAY(name) _DEFINE_OBJARRAY(_wxObjArray##name, name)