home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 10 Tools / 10-Tools.zip / wxos2240.zip / wxWindows-2.4.0 / include / wx / arrimpl.cpp < prev    next >
Text File  |  2002-09-24  |  9KB  |  126 lines
  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,v 1.13.2.1 2002/09/24 00:35:08 RD Exp $
  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)
  126.