src/common/dynarray.cpp

///////////////////////////////////////////////////////////////////////////////
// Name:        src/common/dynarray.cpp
// Purpose:     implementation of wxBaseArray class
// Author:      Vadim Zeitlin
// Modified by:
// Created:     12.09.97
// Copyright:   (c) 1998 Vadim Zeitlin <zeitlin@dptmaths.ens-cachan.fr>
// Licence:     wxWindows licence
///////////////////////////////////////////////////////////////////////////////

// ============================================================================
// headers
// ============================================================================

// For compilers that support precompilation, includes "wx.h".
#include  "wx/wxprec.h"

#ifdef __BORLANDC__
    #pragma hdrstop
#endif

#ifndef WX_PRECOMP
    #include "wx/dynarray.h"
    #include "wx/intl.h"
#endif //WX_PRECOMP

#include <stdlib.h>
#include <string.h> // for memmove

#if !wxUSE_STD_CONTAINERS

// we cast the value to long from which we cast it to void * in IndexForInsert:
// this can't work if the pointers are not big enough
wxCOMPILE_TIME_ASSERT( sizeof(wxUIntPtr) <= sizeof(void *),
                       wxArraySizeOfPtrLessSizeOfLong ); // < 32 symbols

// ============================================================================
// constants
// ============================================================================

// size increment = max(50% of current size, ARRAY_MAXSIZE_INCREMENT)
#define   ARRAY_MAXSIZE_INCREMENT    4096

// ============================================================================
// implementation
// ============================================================================

// ----------------------------------------------------------------------------
// wxBaseArray - dynamic array of 'T's
// ----------------------------------------------------------------------------

#define _WX_DEFINE_BASEARRAY(T, name)                                       \
/* searches the array for an item (forward or backwards) */                 \
int name::Index(T lItem, bool bFromEnd) const                               \
{                                                                           \
  if ( bFromEnd ) {                                                         \
    if ( size() > 0 ) {                                                     \
      size_t n = size();                                                    \
      do {                                                                  \
        if ( (*this)[--n] == lItem )                                        \
          return n;                                                         \
      }                                                                     \
      while ( n != 0 );                                                     \
    }                                                                       \
  }                                                                         \
  else {                                                                    \
    for( size_t n = 0; n < size(); n++ ) {                                  \
      if( (*this)[n] == lItem )                                             \
        return n;                                                           \
    }                                                                       \
  }                                                                         \
                                                                            \
  return wxNOT_FOUND;                                                       \
}                                                                           \
                                                                            \
/* add item assuming the array is sorted with fnCompare function */         \
size_t name::Add(T lItem, CMPFUNC fnCompare)                                \
{                                                                           \
  size_t idx = IndexForInsert(lItem, fnCompare);                            \
  Insert(lItem, idx);                                                       \
  return idx;                                                               \
}                                                                           \
                                                                            \
/* ctor */                                                                  \
name::name()                                                                \
{                                                                           \
  m_nSize  =                                                                \
  m_nCount = 0;                                                             \
  m_pItems = NULL;                                                     \
}                                                                           \
                                                                            \
/* copy ctor */                                                             \
name::name(const name& src)                                                 \
{                                                                           \
  m_nSize  = /* not src.m_nSize to save memory */                           \
  m_nCount = src.m_nCount;                                                  \
                                                                            \
  if ( m_nSize != 0 ) {                                                     \
      m_pItems = new T[m_nSize];                                            \
      /* only copy if allocation succeeded */                               \
      if ( m_pItems ) {                                                     \
          memcpy(m_pItems, src.m_pItems, m_nCount*sizeof(T));               \
      }                                                                     \
      else {                                                                \
          m_nSize = 0;                                                      \
      }                                                                     \
  }                                                                         \
  else                                                                      \
    m_pItems = NULL;                                                  \
}                                                                           \
                                                                            \
/* assignment operator */                                                   \
name& name::operator=(const name& src)                                      \
{                                                                           \
  wxDELETEA(m_pItems);                                                      \
                                                                            \
  m_nSize  = /* not src.m_nSize to save memory */                           \
  m_nCount = src.m_nCount;                                                  \
                                                                            \
  if ( m_nSize != 0 ){                                                      \
      m_pItems = new T[m_nSize];                                            \
      /* only copy if allocation succeeded */                               \
      if ( m_pItems ) {                                                     \
          memcpy(m_pItems, src.m_pItems, m_nCount*sizeof(T));               \
      }                                                                     \
      else {                                                                \
          m_nSize = 0;                                                      \
      }                                                                     \
  }                                                                         \
  else                                                                      \
    m_pItems = NULL;                                                  \
                                                                            \
  return *this;                                                             \
}                                                                           \
                                                                            \
/* allocate new buffer of the given size and move our data to it */         \
bool name::Realloc(size_t nSize)                                            \
{                                                                           \
  T *pNew = new T[nSize];                                                   \
  /* only grow if allocation succeeded */                                   \
  if ( !pNew )                                                              \
      return false;                                                         \
                                                                            \
  m_nSize = nSize;                                                          \
  /* copy data to new location */                                           \
  memcpy(pNew, m_pItems, m_nCount*sizeof(T));                               \
  delete [] m_pItems;                                                       \
  m_pItems = pNew;                                                          \
                                                                            \
  return true;                                                              \
}                                                                           \
                                                                            \
/* grow the array */                                                        \
void name::Grow(size_t nIncrement)                                          \
{                                                                           \
  /* only do it if no more place */                                         \
  if( (m_nCount == m_nSize) || ((m_nSize - m_nCount) < nIncrement) ) {      \
    if( m_nSize == 0 ) {                                                    \
      /* was empty, determine initial size */                               \
      size_t sz = WX_ARRAY_DEFAULT_INITIAL_SIZE;                            \
      if (sz < nIncrement) sz = nIncrement;                                 \
      /* allocate some memory */                                            \
      m_pItems = new T[sz];                                                 \
      /* only grow if allocation succeeded */                               \
      if ( m_pItems ) {                                                     \
          m_nSize = sz;                                                     \
      }                                                                     \
    }                                                                       \
    else                                                                    \
    {                                                                       \
      /* add at least 50% but not too much */                               \
      size_t ndefIncrement = m_nSize < WX_ARRAY_DEFAULT_INITIAL_SIZE        \
                            ? WX_ARRAY_DEFAULT_INITIAL_SIZE : m_nSize >> 1; \
      if ( ndefIncrement > ARRAY_MAXSIZE_INCREMENT )                        \
        ndefIncrement = ARRAY_MAXSIZE_INCREMENT;                            \
      if ( nIncrement < ndefIncrement )                                     \
        nIncrement = ndefIncrement;                                         \
      Realloc(m_nSize + nIncrement);                                        \
    }                                                                       \
  }                                                                         \
}                                                                           \
                                                                            \
/* make sure that the array has at least count elements */                  \
void name::SetCount(size_t count, T defval)                                 \
{                                                                           \
    if ( m_nSize < count )                                                  \
    {                                                                       \
        /* need to realloc memory: don't overallocate it here as if */      \
        /* SetCount() is called, it probably means that the caller  */      \
        /* knows in advance how many elements there will be in the  */      \
        /* array and so it won't be necessary to realloc it later   */      \
        if ( !Realloc(count) )                                              \
        {                                                                   \
            /* out of memory -- what can we do? */                          \
            return;                                                         \
        }                                                                   \
    }                                                                       \
                                                                            \
    /* add new elements if we extend the array */                           \
    while ( m_nCount < count )                                              \
    {                                                                       \
        m_pItems[m_nCount++] = defval;                                      \
    }                                                                       \
}                                                                           \
                                                                            \
/* dtor */                                                                  \
name::~name()                                                               \
{                                                                           \
  wxDELETEA(m_pItems);                                                      \
}                                                                           \
                                                                            \
/* clears the list */                                                       \
void name::Clear()                                                          \
{                                                                           \
  m_nSize  =                                                                \
  m_nCount = 0;                                                             \
                                                                            \
  wxDELETEA(m_pItems);                                                      \
}                                                                           \
                                                                            \
/* minimizes the memory usage by freeing unused memory */                   \
void name::Shrink()                                                         \
{                                                                           \
  /* only do it if we have some memory to free */                           \
  if( m_nCount < m_nSize ) {                                                \
    /* allocates exactly as much memory as we need */                       \
    T *pNew = new T[m_nCount];                                              \
    /* only shrink if allocation succeeded */                               \
    if ( pNew ) {                                                           \
        /* copy data to new location */                                     \
        memcpy(pNew, m_pItems, m_nCount*sizeof(T));                         \
        delete [] m_pItems;                                                 \
        m_pItems = pNew;                                                    \
                                                                            \
        /* update the size of the new block */                              \
        m_nSize = m_nCount;                                                 \
    }                                                                       \
    /* else: don't do anything, better keep old memory block! */            \
  }                                                                         \
}                                                                           \
                                                                            \
/* add item at the end */                                                   \
void name::Add(T lItem, size_t nInsert)                                     \
{                                                                           \
  if (nInsert == 0)                                                         \
      return;                                                               \
  Grow(nInsert);                                                            \
  for (size_t i = 0; i < nInsert; i++)                                      \
      m_pItems[m_nCount++] = lItem;                                         \
}                                                                           \
                                                                            \
/* add item at the given position */                                        \
void name::Insert(T lItem, size_t nIndex, size_t nInsert)                   \
{                                                                           \
  wxCHECK_RET( nIndex <= m_nCount, wxT("bad index in wxArray::Insert") );   \
  wxCHECK_RET( m_nCount <= m_nCount + nInsert,                              \
               wxT("array size overflow in wxArray::Insert") );             \
                                                                            \
  if (nInsert == 0)                                                         \
      return;                                                               \
  Grow(nInsert);                                                            \
                                                                            \
  memmove(&m_pItems[nIndex + nInsert], &m_pItems[nIndex],                   \
          (m_nCount - nIndex)*sizeof(T));                                   \
  for (size_t i = 0; i < nInsert; i++)                                      \
      m_pItems[nIndex + i] = lItem;                                         \
  m_nCount += nInsert;                                                      \
}                                                                           \
                                                                            \
/* search for a place to insert item into sorted array (binary search) */   \
size_t name::IndexForInsert(T lItem, CMPFUNC fnCompare) const               \
{                                                                           \
  size_t i,                                                                 \
       lo = 0,                                                              \
       hi = m_nCount;                                                       \
  int res;                                                                  \
                                                                            \
  while ( lo < hi ) {                                                       \
    i = (lo + hi)/2;                                                        \
                                                                            \
    res = (*fnCompare)((const void *)(wxUIntPtr)lItem,                      \
                       (const void *)(wxUIntPtr)(m_pItems[i]));             \
    if ( res < 0 )                                                          \
      hi = i;                                                               \
    else if ( res > 0 )                                                     \
      lo = i + 1;                                                           \
    else {                                                                  \
      lo = i;                                                               \
      break;                                                                \
    }                                                                       \
  }                                                                         \
                                                                            \
  return lo;                                                                \
}                                                                           \
                                                                            \
/* search for an item in a sorted array (binary search) */                  \
int name::Index(T lItem, CMPFUNC fnCompare) const                           \
{                                                                           \
    size_t n = IndexForInsert(lItem, fnCompare);                            \
                                                                            \
    return (n >= m_nCount ||                                                \
           (*fnCompare)((const void *)(wxUIntPtr)lItem,                     \
                        ((const void *)(wxUIntPtr)m_pItems[n])))            \
                        ? wxNOT_FOUND                                       \
                        : (int)n;                                           \
}                                                                           \
                                                                            \
/* removes item from array (by index) */                                    \
void name::RemoveAt(size_t nIndex, size_t nRemove)                          \
{                                                                           \
  wxCHECK_RET( nIndex < m_nCount, wxT("bad index in wxArray::RemoveAt") );  \
  wxCHECK_RET( nIndex + nRemove <= m_nCount,                                \
               wxT("removing too many elements in wxArray::RemoveAt") );    \
                                                                            \
  memmove(&m_pItems[nIndex], &m_pItems[nIndex + nRemove],                   \
          (m_nCount - nIndex - nRemove)*sizeof(T));                         \
  m_nCount -= nRemove;                                                      \
}                                                                           \
                                                                            \
/* removes item from array (by value) */                                    \
void name::Remove(T lItem)                                                  \
{                                                                           \
  int iIndex = Index(lItem);                                                \
                                                                            \
  wxCHECK_RET( iIndex != wxNOT_FOUND,                                       \
               wxT("removing inexistent item in wxArray::Remove") );        \
                                                                            \
  RemoveAt((size_t)iIndex);                                                 \
}                                                                           \
                                                                            \
/* sort array elements using passed comparaison function */                 \
void name::Sort(CMPFUNC fCmp)                                               \
{                                                                           \
  qsort(m_pItems, m_nCount, sizeof(T), fCmp);                               \
}                                                                           \
                                                                            \
void name::assign(const_iterator first, const_iterator last)                \
{                                                                           \
  clear();                                                                  \
  reserve(last - first);                                                    \
  for(; first != last; ++first)                                             \
    push_back(*first);                                                      \
}                                                                           \
                                                                            \
void name::assign(size_type n, const_reference v)                           \
{                                                                           \
  clear();                                                                  \
  reserve(n);                                                               \
  for( size_type i = 0; i < n; ++i )                                        \
    push_back(v);                                                           \
}                                                                           \
                                                                            \
void name::insert(iterator it, const_iterator first, const_iterator last)   \
{                                                                           \
  size_t nInsert = last - first, nIndex = it - begin();                     \
  if (nInsert == 0)                                                         \
      return;                                                               \
  Grow(nInsert);                                                            \
                                                                            \
  /* old iterator could have been invalidated by Grow(). */                 \
  it = begin() + nIndex;                                                    \
                                                                            \
  memmove(&m_pItems[nIndex + nInsert], &m_pItems[nIndex],                   \
          (m_nCount - nIndex)*sizeof(T));                                   \
  for (size_t i = 0; i < nInsert; ++i, ++it, ++first)                       \
      *it = *first;                                                         \
  m_nCount += nInsert;                                                      \
}

#ifdef __INTELC__
    #pragma warning(push)
    #pragma warning(disable: 1684)
    #pragma warning(disable: 1572)
#endif

_WX_DEFINE_BASEARRAY(const void *, wxBaseArrayPtrVoid)
_WX_DEFINE_BASEARRAY(char,         wxBaseArrayChar)
_WX_DEFINE_BASEARRAY(short,        wxBaseArrayShort)
_WX_DEFINE_BASEARRAY(int,          wxBaseArrayInt)
_WX_DEFINE_BASEARRAY(long,         wxBaseArrayLong)
_WX_DEFINE_BASEARRAY(size_t,       wxBaseArraySizeT)
_WX_DEFINE_BASEARRAY(double,       wxBaseArrayDouble)

#ifdef __INTELC__
    #pragma warning(pop)
#endif

#else // wxUSE_STD_CONTAINERS

#include "wx/arrstr.h"

#include "wx/beforestd.h"
#include <functional>
#include "wx/afterstd.h"

// some compilers (Sun CC being the only known example) distinguish between
// extern "C" functions and the functions with C++ linkage and ptr_fun and
// wxStringCompareLess can't take wxStrcmp/wxStricmp directly as arguments in
// this case, we need the wrappers below to make this work
struct wxStringCmp
{
    typedef wxString first_argument_type;
    typedef wxString second_argument_type;
    typedef int result_type;

    int operator()(const wxString& s1, const wxString& s2) const
    {
        return s1.compare(s2);
    }
};

struct wxStringCmpNoCase
{
    typedef wxString first_argument_type;
    typedef wxString second_argument_type;
    typedef int result_type;

    int operator()(const wxString& s1, const wxString& s2) const
    {
        return s1.CmpNoCase(s2);
    }
};

int wxArrayString::Index(const wxString& str, bool bCase, bool WXUNUSED(bFromEnd)) const
{
    wxArrayString::const_iterator it;

    if (bCase)
    {
        it = std::find_if(begin(), end(),
                          std::not1(
                              std::bind2nd(
                                  wxStringCmp(), str)));
    }
    else // !bCase
    {
        it = std::find_if(begin(), end(),
                          std::not1(
                              std::bind2nd(
                                  wxStringCmpNoCase(), str)));
    }

    return it == end() ? wxNOT_FOUND : it - begin();
}

template<class F>
class wxStringCompareLess
{
public:
    wxStringCompareLess(F f) : m_f(f) { }
    bool operator()(const wxString& s1, const wxString& s2)
        { return m_f(s1, s2) < 0; }
private:
    F m_f;
};

template<class F>
wxStringCompareLess<F> wxStringCompare(F f)
{
    return wxStringCompareLess<F>(f);
}

void wxArrayString::Sort(CompareFunction function)
{
    std::sort(begin(), end(), wxStringCompare(function));
}

void wxArrayString::Sort(bool reverseOrder)
{
    if (reverseOrder)
    {
        std::sort(begin(), end(), std::greater<wxString>());
    }
    else
    {
        std::sort(begin(), end());
    }
}

int wxSortedArrayString::Index(const wxString& str,
                               bool WXUNUSED_UNLESS_DEBUG(bCase),
                               bool WXUNUSED_UNLESS_DEBUG(bFromEnd)) const
{
    wxASSERT_MSG( bCase && !bFromEnd,
                  "search parameters ignored for sorted array" );

    wxSortedArrayString::const_iterator
        it = std::lower_bound(begin(), end(), str, wxStringCompare(wxStringCmp()));

    if ( it == end() || str.Cmp(*it) != 0 )
        return wxNOT_FOUND;

    return it - begin();
}

#endif // !wxUSE_STD_CONTAINERS/wxUSE_STD_CONTAINERS
Commit	Line	Data
	1	///////////////////////////////////////////////////////////////////////////////
	2	// Name: src/common/dynarray.cpp
	3	// Purpose: implementation of wxBaseArray class
	4	// Author: Vadim Zeitlin
	5	// Modified by:
	6	// Created: 12.09.97
	7	// Copyright: (c) 1998 Vadim Zeitlin <zeitlin@dptmaths.ens-cachan.fr>
	8	// Licence: wxWindows licence
	9	///////////////////////////////////////////////////////////////////////////////
	10
	11	// ============================================================================
	12	// headers
	13	// ============================================================================
	14
	15	// For compilers that support precompilation, includes "wx.h".
	16	#include "wx/wxprec.h"
	17
	18	#ifdef __BORLANDC__
	19	#pragma hdrstop
	20	#endif
	21
	22	#ifndef WX_PRECOMP
	23	#include "wx/dynarray.h"
	24	#include "wx/intl.h"
	25	#endif //WX_PRECOMP
	26
	27	#include <stdlib.h>
	28	#include <string.h> // for memmove
	29
	30	#if !wxUSE_STD_CONTAINERS
	31
	32	// we cast the value to long from which we cast it to void * in IndexForInsert:
	33	// this can't work if the pointers are not big enough
	34	wxCOMPILE_TIME_ASSERT( sizeof(wxUIntPtr) <= sizeof(void *),
	35	wxArraySizeOfPtrLessSizeOfLong ); // < 32 symbols
	36
	37	// ============================================================================
	38	// constants
	39	// ============================================================================
	40
	41	// size increment = max(50% of current size, ARRAY_MAXSIZE_INCREMENT)
	42	#define ARRAY_MAXSIZE_INCREMENT 4096
	43
	44	// ============================================================================
	45	// implementation
	46	// ============================================================================
	47
	48	// ----------------------------------------------------------------------------
	49	// wxBaseArray - dynamic array of 'T's
	50	// ----------------------------------------------------------------------------
	51
	52	#define _WX_DEFINE_BASEARRAY(T, name) \
	53	/* searches the array for an item (forward or backwards) */ \
	54	int name::Index(T lItem, bool bFromEnd) const \
	55	{ \
	56	if ( bFromEnd ) { \
	57	if ( size() > 0 ) { \
	58	size_t n = size(); \
	59	do { \
	60	if ( (*this)[--n] == lItem ) \
	61	return n; \
	62	} \
	63	while ( n != 0 ); \
	64	} \
	65	} \
	66	else { \
	67	for( size_t n = 0; n < size(); n++ ) { \
	68	if( (*this)[n] == lItem ) \
	69	return n; \
	70	} \
	71	} \
	72	\
	73	return wxNOT_FOUND; \
	74	} \
	75	\
	76	/* add item assuming the array is sorted with fnCompare function */ \
	77	size_t name::Add(T lItem, CMPFUNC fnCompare) \
	78	{ \
	79	size_t idx = IndexForInsert(lItem, fnCompare); \
	80	Insert(lItem, idx); \
	81	return idx; \
	82	} \
	83	\
	84	/* ctor */ \
	85	name::name() \
	86	{ \
	87	m_nSize = \
	88	m_nCount = 0; \
	89	m_pItems = NULL; \
	90	} \
	91	\
	92	/* copy ctor */ \
	93	name::name(const name& src) \
	94	{ \
	95	m_nSize = /* not src.m_nSize to save memory */ \
	96	m_nCount = src.m_nCount; \
	97	\
	98	if ( m_nSize != 0 ) { \
	99	m_pItems = new T[m_nSize]; \
	100	/* only copy if allocation succeeded */ \
	101	if ( m_pItems ) { \
	102	memcpy(m_pItems, src.m_pItems, m_nCount*sizeof(T)); \
	103	} \
	104	else { \
	105	m_nSize = 0; \
	106	} \
	107	} \
	108	else \
	109	m_pItems = NULL; \
	110	} \
	111	\
	112	/* assignment operator */ \
	113	name& name::operator=(const name& src) \
	114	{ \
	115	wxDELETEA(m_pItems); \
	116	\
	117	m_nSize = /* not src.m_nSize to save memory */ \
	118	m_nCount = src.m_nCount; \
	119	\
	120	if ( m_nSize != 0 ){ \
	121	m_pItems = new T[m_nSize]; \
	122	/* only copy if allocation succeeded */ \
	123	if ( m_pItems ) { \
	124	memcpy(m_pItems, src.m_pItems, m_nCount*sizeof(T)); \
	125	} \
	126	else { \
	127	m_nSize = 0; \
	128	} \
	129	} \
	130	else \
	131	m_pItems = NULL; \
	132	\
	133	return *this; \
	134	} \
	135	\
	136	/* allocate new buffer of the given size and move our data to it */ \
	137	bool name::Realloc(size_t nSize) \
	138	{ \
	139	T *pNew = new T[nSize]; \
	140	/* only grow if allocation succeeded */ \
	141	if ( !pNew ) \
	142	return false; \
	143	\
	144	m_nSize = nSize; \
	145	/* copy data to new location */ \
	146	memcpy(pNew, m_pItems, m_nCount*sizeof(T)); \
	147	delete [] m_pItems; \
	148	m_pItems = pNew; \
	149	\
	150	return true; \
	151	} \
	152	\
	153	/* grow the array */ \
	154	void name::Grow(size_t nIncrement) \
	155	{ \
	156	/* only do it if no more place */ \
	157	if( (m_nCount == m_nSize) \|\| ((m_nSize - m_nCount) < nIncrement) ) { \
	158	if( m_nSize == 0 ) { \
	159	/* was empty, determine initial size */ \
	160	size_t sz = WX_ARRAY_DEFAULT_INITIAL_SIZE; \
	161	if (sz < nIncrement) sz = nIncrement; \
	162	/* allocate some memory */ \
	163	m_pItems = new T[sz]; \
	164	/* only grow if allocation succeeded */ \
	165	if ( m_pItems ) { \
	166	m_nSize = sz; \
	167	} \
	168	} \
	169	else \
	170	{ \
	171	/* add at least 50% but not too much */ \
	172	size_t ndefIncrement = m_nSize < WX_ARRAY_DEFAULT_INITIAL_SIZE \
	173	? WX_ARRAY_DEFAULT_INITIAL_SIZE : m_nSize >> 1; \
	174	if ( ndefIncrement > ARRAY_MAXSIZE_INCREMENT ) \
	175	ndefIncrement = ARRAY_MAXSIZE_INCREMENT; \
	176	if ( nIncrement < ndefIncrement ) \
	177	nIncrement = ndefIncrement; \
	178	Realloc(m_nSize + nIncrement); \
	179	} \
	180	} \
	181	} \
	182	\
	183	/* make sure that the array has at least count elements */ \
	184	void name::SetCount(size_t count, T defval) \
	185	{ \
	186	if ( m_nSize < count ) \
	187	{ \
	188	/* need to realloc memory: don't overallocate it here as if */ \
	189	/* SetCount() is called, it probably means that the caller */ \
	190	/* knows in advance how many elements there will be in the */ \
	191	/* array and so it won't be necessary to realloc it later */ \
	192	if ( !Realloc(count) ) \
	193	{ \
	194	/* out of memory -- what can we do? */ \
	195	return; \
	196	} \
	197	} \
	198	\
	199	/* add new elements if we extend the array */ \
	200	while ( m_nCount < count ) \
	201	{ \
	202	m_pItems[m_nCount++] = defval; \
	203	} \
	204	} \
	205	\
	206	/* dtor */ \
	207	name::~name() \
	208	{ \
	209	wxDELETEA(m_pItems); \
	210	} \
	211	\
	212	/* clears the list */ \
	213	void name::Clear() \
	214	{ \
	215	m_nSize = \
	216	m_nCount = 0; \
	217	\
	218	wxDELETEA(m_pItems); \
	219	} \
	220	\
	221	/* minimizes the memory usage by freeing unused memory */ \
	222	void name::Shrink() \
	223	{ \
	224	/* only do it if we have some memory to free */ \
	225	if( m_nCount < m_nSize ) { \
	226	/* allocates exactly as much memory as we need */ \
	227	T *pNew = new T[m_nCount]; \
	228	/* only shrink if allocation succeeded */ \
	229	if ( pNew ) { \
	230	/* copy data to new location */ \
	231	memcpy(pNew, m_pItems, m_nCount*sizeof(T)); \
	232	delete [] m_pItems; \
	233	m_pItems = pNew; \
	234	\
	235	/* update the size of the new block */ \
	236	m_nSize = m_nCount; \
	237	} \
	238	/* else: don't do anything, better keep old memory block! */ \
	239	} \
	240	} \
	241	\
	242	/* add item at the end */ \
	243	void name::Add(T lItem, size_t nInsert) \
	244	{ \
	245	if (nInsert == 0) \
	246	return; \
	247	Grow(nInsert); \
	248	for (size_t i = 0; i < nInsert; i++) \
	249	m_pItems[m_nCount++] = lItem; \
	250	} \
	251	\
	252	/* add item at the given position */ \
	253	void name::Insert(T lItem, size_t nIndex, size_t nInsert) \
	254	{ \
	255	wxCHECK_RET( nIndex <= m_nCount, wxT("bad index in wxArray::Insert") ); \
	256	wxCHECK_RET( m_nCount <= m_nCount + nInsert, \
	257	wxT("array size overflow in wxArray::Insert") ); \
	258	\
	259	if (nInsert == 0) \
	260	return; \
	261	Grow(nInsert); \
	262	\
	263	memmove(&m_pItems[nIndex + nInsert], &m_pItems[nIndex], \
	264	(m_nCount - nIndex)*sizeof(T)); \
	265	for (size_t i = 0; i < nInsert; i++) \
	266	m_pItems[nIndex + i] = lItem; \
	267	m_nCount += nInsert; \
	268	} \
	269	\
	270	/* search for a place to insert item into sorted array (binary search) */ \
	271	size_t name::IndexForInsert(T lItem, CMPFUNC fnCompare) const \
	272	{ \
	273	size_t i, \
	274	lo = 0, \
	275	hi = m_nCount; \
	276	int res; \
	277	\
	278	while ( lo < hi ) { \
	279	i = (lo + hi)/2; \
	280	\
	281	res = (fnCompare)((const void )(wxUIntPtr)lItem, \
	282	(const void *)(wxUIntPtr)(m_pItems[i])); \
	283	if ( res < 0 ) \
	284	hi = i; \
	285	else if ( res > 0 ) \
	286	lo = i + 1; \
	287	else { \
	288	lo = i; \
	289	break; \
	290	} \
	291	} \
	292	\
	293	return lo; \
	294	} \
	295	\
	296	/* search for an item in a sorted array (binary search) */ \
	297	int name::Index(T lItem, CMPFUNC fnCompare) const \
	298	{ \
	299	size_t n = IndexForInsert(lItem, fnCompare); \
	300	\
	301	return (n >= m_nCount \|\| \
	302	(fnCompare)((const void )(wxUIntPtr)lItem, \
	303	((const void *)(wxUIntPtr)m_pItems[n]))) \
	304	? wxNOT_FOUND \
	305	: (int)n; \
	306	} \
	307	\
	308	/* removes item from array (by index) */ \
	309	void name::RemoveAt(size_t nIndex, size_t nRemove) \
	310	{ \
	311	wxCHECK_RET( nIndex < m_nCount, wxT("bad index in wxArray::RemoveAt") ); \
	312	wxCHECK_RET( nIndex + nRemove <= m_nCount, \
	313	wxT("removing too many elements in wxArray::RemoveAt") ); \
	314	\
	315	memmove(&m_pItems[nIndex], &m_pItems[nIndex + nRemove], \
	316	(m_nCount - nIndex - nRemove)*sizeof(T)); \
	317	m_nCount -= nRemove; \
	318	} \
	319	\
	320	/* removes item from array (by value) */ \
	321	void name::Remove(T lItem) \
	322	{ \
	323	int iIndex = Index(lItem); \
	324	\
	325	wxCHECK_RET( iIndex != wxNOT_FOUND, \
	326	wxT("removing inexistent item in wxArray::Remove") ); \
	327	\
	328	RemoveAt((size_t)iIndex); \
	329	} \
	330	\
	331	/* sort array elements using passed comparaison function */ \
	332	void name::Sort(CMPFUNC fCmp) \
	333	{ \
	334	qsort(m_pItems, m_nCount, sizeof(T), fCmp); \
	335	} \
	336	\
	337	void name::assign(const_iterator first, const_iterator last) \
	338	{ \
	339	clear(); \
	340	reserve(last - first); \
	341	for(; first != last; ++first) \
	342	push_back(*first); \
	343	} \
	344	\
	345	void name::assign(size_type n, const_reference v) \
	346	{ \
	347	clear(); \
	348	reserve(n); \
	349	for( size_type i = 0; i < n; ++i ) \
	350	push_back(v); \
	351	} \
	352	\
	353	void name::insert(iterator it, const_iterator first, const_iterator last) \
	354	{ \
	355	size_t nInsert = last - first, nIndex = it - begin(); \
	356	if (nInsert == 0) \
	357	return; \
	358	Grow(nInsert); \
	359	\
	360	/* old iterator could have been invalidated by Grow(). */ \
	361	it = begin() + nIndex; \
	362	\
	363	memmove(&m_pItems[nIndex + nInsert], &m_pItems[nIndex], \
	364	(m_nCount - nIndex)*sizeof(T)); \
	365	for (size_t i = 0; i < nInsert; ++i, ++it, ++first) \
	366	it = first; \
	367	m_nCount += nInsert; \
	368	}
	369
	370	#ifdef __INTELC__
	371	#pragma warning(push)
	372	#pragma warning(disable: 1684)
	373	#pragma warning(disable: 1572)
	374	#endif
	375
	376	_WX_DEFINE_BASEARRAY(const void *, wxBaseArrayPtrVoid)
	377	_WX_DEFINE_BASEARRAY(char, wxBaseArrayChar)
	378	_WX_DEFINE_BASEARRAY(short, wxBaseArrayShort)
	379	_WX_DEFINE_BASEARRAY(int, wxBaseArrayInt)
	380	_WX_DEFINE_BASEARRAY(long, wxBaseArrayLong)
	381	_WX_DEFINE_BASEARRAY(size_t, wxBaseArraySizeT)
	382	_WX_DEFINE_BASEARRAY(double, wxBaseArrayDouble)
	383
	384	#ifdef __INTELC__
	385	#pragma warning(pop)
	386	#endif
	387
	388	#else // wxUSE_STD_CONTAINERS
	389
	390	#include "wx/arrstr.h"
	391
	392	#include "wx/beforestd.h"
	393	#include <functional>
	394	#include "wx/afterstd.h"
	395
	396	// some compilers (Sun CC being the only known example) distinguish between
	397	// extern "C" functions and the functions with C++ linkage and ptr_fun and
	398	// wxStringCompareLess can't take wxStrcmp/wxStricmp directly as arguments in
	399	// this case, we need the wrappers below to make this work
	400	struct wxStringCmp
	401	{
	402	typedef wxString first_argument_type;
	403	typedef wxString second_argument_type;
	404	typedef int result_type;
	405
	406	int operator()(const wxString& s1, const wxString& s2) const
	407	{
	408	return s1.compare(s2);
	409	}
	410	};
	411
	412	struct wxStringCmpNoCase
	413	{
	414	typedef wxString first_argument_type;
	415	typedef wxString second_argument_type;
	416	typedef int result_type;
	417
	418	int operator()(const wxString& s1, const wxString& s2) const
	419	{
	420	return s1.CmpNoCase(s2);
	421	}
	422	};
	423
	424	int wxArrayString::Index(const wxString& str, bool bCase, bool WXUNUSED(bFromEnd)) const
	425	{
	426	wxArrayString::const_iterator it;
	427
	428	if (bCase)
	429	{
	430	it = std::find_if(begin(), end(),
	431	std::not1(
	432	std::bind2nd(
	433	wxStringCmp(), str)));
	434	}
	435	else // !bCase
	436	{
	437	it = std::find_if(begin(), end(),
	438	std::not1(
	439	std::bind2nd(
	440	wxStringCmpNoCase(), str)));
	441	}
	442
	443	return it == end() ? wxNOT_FOUND : it - begin();
	444	}
	445
	446	template<class F>
	447	class wxStringCompareLess
	448	{
	449	public:
	450	wxStringCompareLess(F f) : m_f(f) { }
	451	bool operator()(const wxString& s1, const wxString& s2)
	452	{ return m_f(s1, s2) < 0; }
	453	private:
	454	F m_f;
	455	};
	456
	457	template<class F>
	458	wxStringCompareLess<F> wxStringCompare(F f)
	459	{
	460	return wxStringCompareLess<F>(f);
	461	}
	462
	463	void wxArrayString::Sort(CompareFunction function)
	464	{
	465	std::sort(begin(), end(), wxStringCompare(function));
	466	}
	467
	468	void wxArrayString::Sort(bool reverseOrder)
	469	{
	470	if (reverseOrder)
	471	{
	472	std::sort(begin(), end(), std::greater<wxString>());
	473	}
	474	else
	475	{
	476	std::sort(begin(), end());
	477	}
	478	}
	479
	480	int wxSortedArrayString::Index(const wxString& str,
	481	bool WXUNUSED_UNLESS_DEBUG(bCase),
	482	bool WXUNUSED_UNLESS_DEBUG(bFromEnd)) const
	483	{
	484	wxASSERT_MSG( bCase && !bFromEnd,
	485	"search parameters ignored for sorted array" );
	486
	487	wxSortedArrayString::const_iterator
	488	it = std::lower_bound(begin(), end(), str, wxStringCompare(wxStringCmp()));
	489
	490	if ( it == end() \|\| str.Cmp(*it) != 0 )
	491	return wxNOT_FOUND;
	492
	493	return it - begin();
	494	}
	495
	496	#endif // !wxUSE_STD_CONTAINERS/wxUSE_STD_CONTAINERS