[wxWidgets.git] / include / wx / arrimpl.cpp

///////////////////////////////////////////////////////////////////////////////
// Name:        wx/arrimpl.cpp
// Purpose:     helper file for implementation of dynamic lists
// Author:      Vadim Zeitlin
// Modified by:
// Created:     16.10.97
// RCS-ID:      $Id$
// Copyright:   (c) 1997 Vadim Zeitlin <zeitlin@dptmaths.ens-cachan.fr>
// Licence:     wxWindows licence
///////////////////////////////////////////////////////////////////////////////

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

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

#define _WX_ERROR_REMOVE2(x)     wxT("bad index in ") wxT(#x) wxT("::RemoveAt()")

// macro implements remaining (not inline) methods of template list
// (it's private to this file)
#undef  _DEFINE_OBJARRAY
#define _DEFINE_OBJARRAY(T, name)                                             \
name::~name()                                                                 \
{                                                                             \
  Empty();                                                                    \
}                                                                             \
                                                                              \
void name::DoCopy(const name& src)                                            \
{                                                                             \
  for ( size_t ui = 0; ui < src.size(); ui++ )                                \
    Add(src[ui]);                                                             \
}                                                                             \
                                                                              \
name& name::operator=(const name& src)                                        \
{                                                                             \
  Empty();                                                                    \
  DoCopy(src);                                                                \
                                                                              \
  return *this;                                                               \
}                                                                             \
                                                                              \
name::name(const name& src) : wxArrayPtrVoid()                                \
{                                                                             \
  DoCopy(src);                                                                \
}                                                                             \
                                                                              \
void name::DoEmpty()                                                          \
{                                                                             \
  for ( size_t ui = 0; ui < size(); ui++ )                                    \
    delete (T*)base_array::operator[](ui);                                    \
}                                                                             \
                                                                              \
void name::RemoveAt(size_t uiIndex, size_t nRemove)                           \
{                                                                             \
  wxCHECK_RET( uiIndex < size(), _WX_ERROR_REMOVE2(name) );                   \
                                                                              \
  for (size_t i = 0; i < nRemove; i++ )                                       \
    delete (T*)base_array::operator[](uiIndex + i);                           \
                                                                              \
  base_array::erase(begin() + uiIndex, begin() + uiIndex + nRemove);          \
}                                                                             \
                                                                              \
void name::Add(const T& item, size_t nInsert)                                 \
{                                                                             \
  if (nInsert == 0)                                                           \
    return;                                                                   \
  T* pItem = new T(item);                                                     \
  size_t nOldSize = size();                                                   \
  if ( pItem != NULL )                                                        \
    base_array::insert(end(), nInsert, pItem);                                \
  for (size_t i = 1; i < nInsert; i++)                                        \
    base_array::operator[](nOldSize + i) = new T(item);                       \
}                                                                             \
                                                                              \
void name::Insert(const T& item, size_t uiIndex, size_t nInsert)              \
{                                                                             \
  if (nInsert == 0)                                                           \
    return;                                                                   \
  T* pItem = new T(item);                                                     \
  if ( pItem != NULL )                                                        \
    base_array::insert(begin() + uiIndex, nInsert, pItem);                    \
  for (size_t i = 1; i < nInsert; i++)                                        \
    base_array::operator[](uiIndex + i) = new T(item);                        \
}                                                                             \
                                                                              \
int name::Index(const T& item, bool bFromEnd) const                           \
{                                                                             \
  if ( bFromEnd ) {                                                           \
    if ( size() > 0 ) {                                                       \
      size_t ui = size() - 1;                                                 \
      do {                                                                    \
        if ( (T*)base_array::operator[](ui) == &item )                        \
          return static_cast<int>(ui);                                     \
        ui--;                                                                 \
      }                                                                       \
      while ( ui != 0 );                                                      \
    }                                                                         \
  }                                                                           \
  else {                                                                      \
    for( size_t ui = 0; ui < size(); ui++ ) {                                 \
      if( (T*)base_array::operator[](ui) == &item )                           \
        return static_cast<int>(ui);                                       \
    }                                                                         \
  }                                                                           \
                                                                              \
  return wxNOT_FOUND;                                                         \
}

// redefine the macro so that now it will generate the class implementation
// old value would provoke a compile-time error if this file is not included
#undef  WX_DEFINE_OBJARRAY
#define WX_DEFINE_OBJARRAY(name) _DEFINE_OBJARRAY(_wxObjArray##name, name)
Commit	Line	Data
0297f5c6	1	///////////////////////////////////////////////////////////////////////////////
1a931653	2	// Name: wx/arrimpl.cpp
0297f5c6 VZ	3	// Purpose: helper file for implementation of dynamic lists
0297f5c6 VZ	4	// Author: Vadim Zeitlin
e90c1d2a	5	// Modified by:
0297f5c6 VZ	6	// Created: 16.10.97
	7	// RCS-ID: $Id$
	8	// Copyright: (c) 1997 Vadim Zeitlin <zeitlin@dptmaths.ens-cachan.fr>
526954c5	9	// Licence: wxWindows licence
0297f5c6 VZ	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
e90c1d2a	23	// needed to resolve the conflict between global T and macro parameter T
fbdcff4a	24
eee3624b	25	#define _WX_ERROR_REMOVE2(x) wxT("bad index in ") wxT(#x) wxT("::RemoveAt()")
e90c1d2a	26
0297f5c6 VZ	27	// macro implements remaining (not inline) methods of template list
0297f5c6 VZ	28	// (it's private to this file)
22692cf6 VZ	29	#undef _DEFINE_OBJARRAY
22692cf6 VZ	30	#define _DEFINE_OBJARRAY(T, name) \
0297f5c6 VZ	31	name::~name() \
	32	{ \
	33	Empty(); \
	34	} \
	35	\
	36	void name::DoCopy(const name& src) \
	37	{ \
df5168c4	38	for ( size_t ui = 0; ui < src.size(); ui++ ) \
0297f5c6 VZ	39	Add(src[ui]); \
	40	} \
	41	\
	42	name& name::operator=(const name& src) \
	43	{ \
	44	Empty(); \
	45	DoCopy(src); \
	46	\
	47	return *this; \
	48	} \
	49	\
d84afea9	50	name::name(const name& src) : wxArrayPtrVoid() \
0297f5c6 VZ	51	{ \
	52	DoCopy(src); \
	53	} \
	54	\
f6bcfd97	55	void name::DoEmpty() \
0297f5c6	56	{ \
df5168c4 MB	57	for ( size_t ui = 0; ui < size(); ui++ ) \
df5168c4 MB	58	delete (T*)base_array::operator[](ui); \
0297f5c6 VZ	59	} \
0297f5c6 VZ	60	\
3b0b5f13	61	void name::RemoveAt(size_t uiIndex, size_t nRemove) \
0297f5c6	62	{ \
df5168c4	63	wxCHECK_RET( uiIndex < size(), _WX_ERROR_REMOVE2(name) ); \
0297f5c6	64	\
3b0b5f13	65	for (size_t i = 0; i < nRemove; i++ ) \
df5168c4	66	delete (T*)base_array::operator[](uiIndex + i); \
0297f5c6	67	\
df5168c4	68	base_array::erase(begin() + uiIndex, begin() + uiIndex + nRemove); \
0297f5c6 VZ	69	} \
0297f5c6 VZ	70	\
3b0b5f13	71	void name::Add(const T& item, size_t nInsert) \
0297f5c6	72	{ \
2b5f62a0 VZ	73	if (nInsert == 0) \
2b5f62a0 VZ	74	return; \
0297f5c6	75	T* pItem = new T(item); \
df5168c4	76	size_t nOldSize = size(); \
0297f5c6	77	if ( pItem != NULL ) \
df5168c4	78	base_array::insert(end(), nInsert, pItem); \
3b0b5f13	79	for (size_t i = 1; i < nInsert; i++) \
df5168c4	80	base_array::operator[](nOldSize + i) = new T(item); \
0297f5c6 VZ	81	} \
0297f5c6 VZ	82	\
3b0b5f13	83	void name::Insert(const T& item, size_t uiIndex, size_t nInsert) \
0297f5c6	84	{ \
2b5f62a0 VZ	85	if (nInsert == 0) \
2b5f62a0 VZ	86	return; \
0297f5c6 VZ	87	T* pItem = new T(item); \
0297f5c6 VZ	88	if ( pItem != NULL ) \
df5168c4	89	base_array::insert(begin() + uiIndex, nInsert, pItem); \
3b0b5f13	90	for (size_t i = 1; i < nInsert; i++) \
df5168c4	91	base_array::operator[](uiIndex + i) = new T(item); \
0297f5c6 VZ	92	} \
0297f5c6 VZ	93	\
7d1214cd	94	int name::Index(const T& item, bool bFromEnd) const \
0297f5c6 VZ	95	{ \
0297f5c6 VZ	96	if ( bFromEnd ) { \
df5168c4 MB	97	if ( size() > 0 ) { \
df5168c4 MB	98	size_t ui = size() - 1; \
0297f5c6	99	do { \
7d1214cd	100	if ( (T*)base_array::operator[](ui) == &item ) \
5c33522f	101	return static_cast<int>(ui); \
0297f5c6 VZ	102	ui--; \
	103	} \
	104	while ( ui != 0 ); \
	105	} \
	106	} \
	107	else { \
df5168c4	108	for( size_t ui = 0; ui < size(); ui++ ) { \
7d1214cd	109	if( (T*)base_array::operator[](ui) == &item ) \
5c33522f	110	return static_cast<int>(ui); \
0297f5c6 VZ	111	} \
	112	} \
	113	\
e90c1d2a VZ	114	return wxNOT_FOUND; \
e90c1d2a VZ	115	}
0297f5c6 VZ	116
	117	// redefine the macro so that now it will generate the class implementation
	118	// old value would provoke a compile-time error if this file is not included
	119	#undef WX_DEFINE_OBJARRAY
1a931653	120	#define WX_DEFINE_OBJARRAY(name) _DEFINE_OBJARRAY(_wxObjArray##name, name)