include/wx/arrimpl.cpp

   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$
   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)                                                   \
  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   T* pItem = new T(item);                                                     \
  79   size_t nOldSize = GetCount();                                               \
  80   if ( pItem != NULL )                                                        \
  81     wxBaseArrayPtrVoid::Add(pItem, nInsert);                                  \
  82   for (size_t i = 1; i < nInsert; i++)                                        \
  83     wxBaseArrayPtrVoid::Item(nOldSize + i) = new T(item);                     \
  84 }                                                                             \
  85                                                                               \
  86 void name::Insert(const T& item, size_t uiIndex, size_t nInsert)              \
  87 {                                                                             \
  88   T* pItem = new T(item);                                                     \
  89   if ( pItem != NULL )                                                        \
  90     wxBaseArrayPtrVoid::Insert(pItem, uiIndex, nInsert);                      \
  91   for (size_t i = 1; i < nInsert; i++)                                        \
  92     wxBaseArrayPtrVoid::Item(uiIndex + i) = new T(item);                      \
  93 }                                                                             \
  94                                                                               \
  95 int name::Index(const T& Item, bool bFromEnd) const                           \
  96 {                                                                             \
  97   if ( bFromEnd ) {                                                           \
  98     if ( Count() > 0 ) {                                                      \
  99       size_t ui = Count() - 1;                                                \
 100       do {                                                                    \
 101         if ( (T*)wxBaseArrayPtrVoid::Item(ui) == &Item )                      \
 102           return ui;                                                          \
 103         ui--;                                                                 \
 104       }                                                                       \
 105       while ( ui != 0 );                                                      \
 106     }                                                                         \
 107   }                                                                           \
 108   else {                                                                      \
 109     for( size_t ui = 0; ui < Count(); ui++ ) {                                \
 110       if( (T*)wxBaseArrayPtrVoid::Item(ui) == &Item )                         \
 111         return ui;                                                            \
 112     }                                                                         \
 113   }                                                                           \
 114                                                                               \
 115   return wxNOT_FOUND;                                                         \
 116 }
 117
 118 // redefine the macro so that now it will generate the class implementation
 119 // old value would provoke a compile-time error if this file is not included
 120 #undef  WX_DEFINE_OBJARRAY
 121 #define WX_DEFINE_OBJARRAY(name) _DEFINE_OBJARRAY(_wxObjArray##name, name)