-/////////////////////////////////////////////////////////////////////////////
+////////////////////////////////////////////////////////////////////////////////
// Name: list.cpp
// Purpose: wxList implementation
// Author: Julian Smart
-// Modified by:
+// Modified by: VZ at 16/11/98: WX_DECLARE_LIST() and typesafe lists added
// Created: 04/01/98
// RCS-ID: $Id$
// Copyright: (c) Julian Smart and Markus Holzem
-// Licence: wxWindows license
-/////////////////////////////////////////////////////////////////////////////
+// Licence: wxWindows license
+////////////////////////////////////////////////////////////////////////////////
+// =============================================================================
+// declarations
+// =============================================================================
+
+// -----------------------------------------------------------------------------
+// headers
+// -----------------------------------------------------------------------------
#ifdef __GNUG__
#pragma implementation "list.h"
#endif
#include "wx/wxprec.h"
#ifdef __BORLANDC__
-#pragma hdrstop
-#endif
-
-#ifndef WX_PRECOMP
-#include "wx/defs.h"
-#include "wx/list.h"
-#include "wx/utils.h"
-#endif
-
-// Sun CC compatibility (interference with xview/pkg.h, apparently...)
-#if defined(SUN_CC) && defined(__XVIEW__)
-#undef va_start
-#undef va_end
-#undef va_arg
-#undef va_list
+ #pragma hdrstop
#endif
#include <stdarg.h>
#include <stdlib.h>
#include <string.h>
-#if !USE_SHARED_LIBRARY
-IMPLEMENT_DYNAMIC_CLASS(wxNode, wxObject)
-IMPLEMENT_DYNAMIC_CLASS(wxList, wxObject)
-IMPLEMENT_DYNAMIC_CLASS(wxStringList, wxList)
+#ifndef WX_PRECOMP
+ #include "wx/defs.h"
+ #include "wx/list.h"
+ #include "wx/utils.h" // for copystring() (beurk...)
#endif
-wxNode::wxNode (wxList * the_list, wxNode * last_one, wxNode * next_one,
- wxObject * object)
-{
- data = object;
- previous = last_one;
- next = next_one;
- list = the_list;
- key.string = NULL;
+// -----------------------------------------------------------------------------
+// implementation of standard lists
+// -----------------------------------------------------------------------------
- if (previous)
- previous->next = this;
+#include "wx/listimpl.cpp"
+WX_DEFINE_LIST(wxWindowList);
- if (next)
- next->previous = this;
-}
+// =============================================================================
+// implementation
+// =============================================================================
-// Keyed constructor
-wxNode::wxNode (wxList * the_list, wxNode * last_one, wxNode * next_one,
- wxObject * object, long the_key)
-{
- data = object;
- previous = last_one;
- next = next_one;
- list = the_list;
- key.integer = the_key;
+// -----------------------------------------------------------------------------
+// wxListKey
+// -----------------------------------------------------------------------------
- if (previous)
- previous->next = this;
+wxListKey wxDefaultListKey;
- if (next)
- next->previous = this;
-}
-
-wxNode::wxNode (wxList * the_list, wxNode * last_one, wxNode * next_one,
- wxObject * object, const char *the_key)
+bool wxListKey::operator==(wxListKeyValue value) const
{
- data = object;
- previous = last_one;
- next = next_one;
- list = the_list;
- key.string = copystring (the_key);
+ switch ( m_keyType )
+ {
+ default:
+ wxFAIL_MSG("bad key type.");
+ // let compiler optimize the line above away in release build
+ // by not putting return here...
- if (previous)
- previous->next = this;
+ case wxKEY_STRING:
+ return strcmp(m_key.string, value.string) == 0;
- if (next)
- next->previous = this;
+ case wxKEY_INTEGER:
+ return m_key.integer == value.integer;
+ }
}
+// -----------------------------------------------------------------------------
+// wxNodeBase
+// -----------------------------------------------------------------------------
-wxNode::~wxNode (void)
+wxNodeBase::wxNodeBase(wxListBase *list,
+ wxNodeBase *previous, wxNodeBase *next,
+ void *data, const wxListKey& key)
{
- if (list)
- list->n--;
+ m_list = list;
+ m_data = data;
+ m_previous = previous;
+ m_next = next;
+
+ switch ( key.GetKeyType() )
+ {
+ case wxKEY_NONE:
+ break;
- if (list && list->destroy_data)
- delete data;
+ case wxKEY_INTEGER:
+ m_key.integer = key.GetNumber();
+ break;
- if (list && list->key_type == wxKEY_STRING && key.string)
- delete[]key.string;
+ case wxKEY_STRING:
+ // to be free()d later
+ m_key.string = strdup(key.GetString());
+ break;
- // Make next node point back to the previous node from here
- if (next)
- next->previous = previous;
- else if (list)
- // If there's a new end of list (deleting the last one)
- // make sure the list knows about it.
- list->last_node = previous;
+ default:
+ wxFAIL_MSG("invalid key type");
+ }
- // Make the previous node point to the next node from here
- if (previous)
- previous->next = next;
+ if ( previous )
+ previous->m_next = this;
- // Or if no previous node (start of list), make sure list points at
- // the next node which becomes the first!.
- else if (list)
- list->first_node = next;
+ if ( next )
+ next->m_previous = this;
}
-wxList::wxList (void)
+wxNodeBase::~wxNodeBase()
{
- first_node = NULL;
- last_node = NULL;
- n = 0;
- destroy_data = 0;
- key_type = wxKEY_NONE;
+ // handle the case when we're being deleted from the list by the user (i.e.
+ // not by the list itself from DeleteNode) - we must do it for
+ // compatibility with old code
+ if ( m_list != NULL )
+ {
+ if ( m_list->m_keyType == wxKEY_STRING )
+ {
+ free(m_key.string);
+ }
+
+ m_list->DetachNode(this);
+ }
}
-wxList::wxList (int N, wxObject * Objects[])
+int wxNodeBase::IndexOf() const
{
- wxNode *last = NULL;
+ wxCHECK_MSG( m_list, wxNOT_FOUND, "node doesn't belong to a list in IndexOf");
+
+ // It would be more efficient to implement IndexOf() completely inside
+ // wxListBase (only traverse the list once), but this is probably a more
+ // reusable way of doing it. Can always be optimized at a later date (since
+ // IndexOf() resides in wxListBase as well) if efficiency is a problem.
+ int i;
+ wxNodeBase *prev = m_previous;
- int i;
- for (i = 0; i < N; i++)
+ for( i = 0; prev; i++ )
{
- wxNode *next = new wxNode (this, last, NULL, Objects[i]);
- last = next;
- if (i == 0)
- first_node = next;
+ prev = prev->m_previous;
}
- last_node = last;
- n = N;
- key_type = wxKEY_NONE;
+
+ return i;
}
-wxList::wxList (const unsigned int the_key_type)
+// -----------------------------------------------------------------------------
+// wxListBase
+// -----------------------------------------------------------------------------
+
+void wxListBase::Init(wxKeyType keyType)
{
- n = 0;
- destroy_data = 0;
- first_node = NULL;
- last_node = NULL;
- key_type = the_key_type;
+ m_nodeFirst =
+ m_nodeLast = (wxNodeBase *) NULL;
+ m_count = 0;
+ m_destroy = FALSE;
+ m_keyType = keyType;
}
-// Variable argument list, terminated by a zero
-wxList::wxList (wxObject * first_one...)
+wxListBase::wxListBase(size_t count, void *elements[])
{
-// #ifndef __SGI__
- va_list ap;
+ Init();
+
+ for ( size_t n = 0; n < count; n++ )
+ {
+ Append(elements[n]);
+ }
+}
- va_start (ap, first_one);
+void wxListBase::DoCopy(const wxListBase& list)
+{
+ wxASSERT_MSG( !list.m_destroy,
+ "copying list which owns it's elements is a bad idea" );
- wxNode *last = new wxNode (this, NULL, NULL, first_one);
- first_node = last;
- n = 1;
+ m_count = list.m_count;
+ m_destroy = list.m_destroy;
+ m_keyType = list.m_keyType;
+ m_nodeFirst =
+ m_nodeLast = (wxNodeBase *) NULL;
- for (;;)
+ for ( wxNodeBase *node = list.GetFirst(); node; node = node->GetNext() )
{
- wxObject *object = va_arg (ap, wxObject *);
-// if (object == NULL) // Doesn't work in Windows -- segment is non-zero for NULL!
-#ifdef __WXMSW__
- if ((int) object == 0)
-#else
- if ((long) object == 0)
-#endif
- break;
- else
- {
- wxNode *node = new wxNode (this, last, NULL, object);
- last = node;
- n++;
- }
+ Append(node);
}
- last_node = last;
- va_end (ap);
+}
- destroy_data = 0;
- key_type = wxKEY_NONE;
-/*
-#else
- fprintf (stderr, "Error: cannot use variable-argument functions on SGI!\n");
-#endif
-*/
+wxListBase::~wxListBase()
+{
+ wxNodeBase *each = m_nodeFirst;
+ while ( each != NULL )
+ {
+ wxNodeBase *next = each->GetNext();
+ DoDeleteNode(each);
+ each = next;
+ }
}
-wxList::~wxList (void)
+wxNodeBase *wxListBase::AppendCommon(wxNodeBase *node)
{
- wxNode *each = first_node;
- while (each)
+ if ( !m_nodeFirst )
{
- wxNode *next = each->Next ();
- delete each;
- each = next;
+ m_nodeFirst = node;
+ m_nodeLast = m_nodeFirst;
+ }
+ else
+ {
+ m_nodeLast->m_next = node;
+ m_nodeLast = node;
}
+
+ m_count++;
+
+ return node;
}
-wxNode *wxList::Append(wxObject *object)
+wxNodeBase *wxListBase::Append(void *object)
{
- wxNode *node = new wxNode(this, last_node, NULL, object);
- if (!first_node)
- first_node = node;
- last_node = node;
- n ++;
- return node;
+ // all objects in a keyed list should have a key
+ wxCHECK_MSG( m_keyType == wxKEY_NONE, (wxNodeBase *)NULL,
+ "need a key for the object to append" );
+
+ wxNodeBase *node = CreateNode(m_nodeLast, (wxNodeBase *)NULL, object);
+
+ return AppendCommon(node);
}
-wxNode *wxList::Nth (int i) const
+wxNodeBase *wxListBase::Append(long key, void *object)
{
- int j = 0;
- for (wxNode * current = First (); current; current = current->Next ())
- {
- if (j++ == i)
- return current;
- }
- return NULL; // No such element
+ wxCHECK_MSG( (m_keyType == wxKEY_INTEGER) ||
+ (m_keyType == wxKEY_NONE && m_count == 0),
+ (wxNodeBase *)NULL,
+ "can't append object with numeric key to this list" );
+ wxNodeBase *node = CreateNode(m_nodeLast, (wxNodeBase *)NULL, object, key);
+ return AppendCommon(node);
}
-wxNode *wxList::Find (long key) const
+wxNodeBase *wxListBase::Append (const char *key, void *object)
{
- wxNode *current = First();
- while (current)
- {
- if (current->key.integer == key)
- return current;
- current = current->Next();
- }
-
- return NULL; // Not found!
+ wxCHECK_MSG( (m_keyType == wxKEY_STRING) ||
+ (m_keyType == wxKEY_NONE && m_count == 0),
+ (wxNodeBase *)NULL,
+ "can't append object with string key to this list" );
+
+ wxNodeBase *node = CreateNode(m_nodeLast, (wxNodeBase *)NULL, object, key);
+ return AppendCommon(node);
}
-wxNode *wxList::Find (const char *key) const
+wxNodeBase *wxListBase::Insert(wxNodeBase *position, void *object)
{
- wxNode *current = First();
- while (current)
- {
- if (!current->key.string)
- {
- wxFatalError ("wxList: string key not present, probably did not Append correctly!");
- break;
- }
- if (strcmp (current->key.string, key) == 0)
- return current;
- current = current->Next();
- }
+ // all objects in a keyed list should have a key
+ wxCHECK_MSG( m_keyType == wxKEY_NONE, (wxNodeBase *)NULL,
+ "need a key for the object to insert" );
- return NULL; // Not found!
+ wxCHECK_MSG( !position || position->m_list == this, (wxNodeBase *)NULL,
+ "can't insert before a node from another list" );
+
+ // previous and next node for the node being inserted
+ wxNodeBase *prev, *next;
+ if ( position )
+ {
+ prev = position->GetPrevious();
+ next = position;
+ }
+ else
+ {
+ // inserting in the beginning of the list
+ prev = (wxNodeBase *)NULL;
+ next = m_nodeFirst;
+ }
+ wxNodeBase *node = CreateNode(prev, next, object);
+ if ( !m_nodeFirst )
+ {
+ m_nodeLast = node;
+ }
+
+ if ( prev == NULL )
+ {
+ m_nodeFirst = node;
+ }
+
+ m_count++;
+
+ return node;
}
-wxNode *wxList::Member (wxObject * object) const
+wxNodeBase *wxListBase::Item(size_t n) const
{
- for (wxNode * current = First (); current; current = current->Next ())
+ for ( wxNodeBase *current = GetFirst(); current; current = current->GetNext() )
{
- wxObject *each = current->Data ();
- if (each == object)
- return current;
+ if ( n-- == 0 )
+ {
+ return current;
+ }
}
- return NULL;
+
+ wxFAIL_MSG( "invalid index in wxListBase::Item" );
+
+ return (wxNodeBase *)NULL;
}
-bool wxList::DeleteNode (wxNode * node)
+wxNodeBase *wxListBase::Find(const wxListKey& key) const
{
- if (node)
+ wxASSERT_MSG( m_keyType == key.GetKeyType(),
+ "this list is not keyed on the type of this key" );
+
+ for ( wxNodeBase *current = GetFirst(); current; current = current->GetNext() )
{
- delete node;
- return TRUE;
+ if ( key == current->m_key )
+ {
+ return current;
+ }
}
- return FALSE;
+
+ // not found
+ return (wxNodeBase *)NULL;
}
-bool wxList::DeleteObject (wxObject * object)
+wxNodeBase *wxListBase::Find(void *object) const
{
- // Search list for object
- for (wxNode * current = first_node; current; current = current->Next ())
+ for ( wxNodeBase *current = GetFirst(); current; current = current->GetNext() )
{
- if (current->Data () == object)
- {
- delete current;
- return TRUE;
- }
+ if ( current->GetData() == object )
+ return current;
}
- return FALSE; // Did not find the object
+ // not found
+ return (wxNodeBase *)NULL;
}
-
-// Insert new node at front of list
-wxNode *wxList::Insert (wxObject * object)
+int wxListBase::IndexOf(void *object) const
{
- wxNode *node = new wxNode (this, NULL, First (), object);
- first_node = node;
+ wxNodeBase *node = Find( object );
- if (!(node->Next ()))
- last_node = node;
-
- n++;
- return node;
+ return node ? node->IndexOf() : wxNOT_FOUND;
}
-
-// Insert new node before given node.
-wxNode *wxList::Insert (wxNode * position, wxObject * object)
+void wxListBase::DoDeleteNode(wxNodeBase *node)
{
- wxNode *prev = NULL;
- if (position)
- prev = position->Previous ();
+ // free node's data
+ if ( m_keyType == wxKEY_STRING )
+ {
+ free(node->m_key.string);
+ }
- wxNode *node = new wxNode (this, prev, position, object);
- if (!first_node)
+ if ( m_destroy )
{
- first_node = node;
- last_node = node;
+ node->DeleteData();
}
- if (!prev)
- first_node = node;
- n++;
- return node;
+ // so that the node knows that it's being deleted by the list
+ node->m_list = NULL;
+ delete node;
}
-// Keyed append
-wxNode *wxList::Append (long key, wxObject * object)
+wxNodeBase *wxListBase::DetachNode(wxNodeBase *node)
{
- wxNode *node = new wxNode (this, last_node, NULL, object, key);
- if (!first_node)
- first_node = node;
- last_node = node;
- n++;
- return node;
+ wxCHECK_MSG( node, NULL, "detaching NULL wxNodeBase" );
+ wxCHECK_MSG( node->m_list == this, NULL,
+ "detaching node which is not from this list" );
+
+ // update the list
+ wxNodeBase **prevNext = node->GetPrevious() ? &node->GetPrevious()->m_next
+ : &m_nodeFirst;
+ wxNodeBase **nextPrev = node->GetNext() ? &node->GetNext()->m_previous
+ : &m_nodeLast;
+
+ *prevNext = node->GetNext();
+ *nextPrev = node->GetPrevious();
+
+ m_count--;
+
+ // mark the node as not belonging to this list any more
+ node->m_list = NULL;
+
+ return node;
}
-wxNode *wxList::Append (const char *key, wxObject * object)
+bool wxListBase::DeleteNode(wxNodeBase *node)
{
- wxNode *node = new wxNode (this, last_node, NULL, object, key);
- if (!first_node)
- first_node = node;
- last_node = node;
- n++;
- return node;
+ if ( !DetachNode(node) )
+ return FALSE;
+
+ DoDeleteNode(node);
+
+ return TRUE;
}
-void wxList::Clear (void)
+bool wxListBase::DeleteObject(void *object)
{
- wxNode *current = first_node;
- while (current)
+ for ( wxNodeBase *current = GetFirst(); current; current = current->GetNext() )
{
- wxNode *next = current->Next ();
- delete current;
- current = next;
+ if ( current->GetData() == object )
+ {
+ DeleteNode(current);
+ return TRUE;
+ }
}
- first_node = NULL;
- last_node = NULL;
- n = 0;
+
+ // not found
+ return FALSE;
}
-//Executes function F with all items present in the list
-void wxList::ForEach(wxListIterateFunction F)
+void wxListBase::Clear()
{
- wxNode *each = first_node;
- while (each)
- { (*F)( each->Data ());
- each = each->Next();
+ wxNodeBase *current = m_nodeFirst;
+ while ( current )
+ {
+ wxNodeBase *next = current->GetNext();
+ DoDeleteNode(current);
+ current = next;
}
+
+ m_nodeFirst =
+ m_nodeLast = (wxNodeBase *)NULL;
+
+ m_count = 0;
}
-// Returns a pointer to the item which returns TRUE with function F
-// or NULL if no such item found
-wxObject *wxList::FirstThat(wxListIterateFunction F)
+
+void wxListBase::ForEach(wxListIterateFunction F)
{
- wxNode *each = first_node;
- while (each)
- { if ((*F)( each->Data ())) return each->Data();
- each = each->Next();
+ for ( wxNodeBase *current = GetFirst(); current; current = current->GetNext() )
+ {
+ (*F)(current->GetData());
}
- return NULL;
}
-// Like FirstThat, but proceeds from the end backward
-wxObject *wxList::LastThat(wxListIterateFunction F)
+
+void *wxListBase::FirstThat(wxListIterateFunction F)
+{
+ for ( wxNodeBase *current = GetFirst(); current; current = current->GetNext() )
+ {
+ if ( (*F)(current->GetData()) )
+ return current->GetData();
+ }
+
+ return (wxNodeBase *)NULL;
+}
+
+void *wxListBase::LastThat(wxListIterateFunction F)
{
- wxNode *each = last_node;
- while (each)
- { if ((*F)( each->Data ())) return each->Data();
- each = each->Previous();
+ for ( wxNodeBase *current = GetLast(); current; current = current->GetPrevious() )
+ {
+ if ( (*F)(current->GetData()) )
+ return current->GetData();
}
- return NULL;
+
+ return (wxNodeBase *)NULL;
}
// (stefan.hammes@urz.uni-heidelberg.de)
// }
//
// void main()
-// {
-// wxList list;
+// {
+// wxListBase list;
//
// list.Append(new wxString("DEF"));
// list.Append(new wxString("GHI"));
// list.Sort(listcompare);
// }
-void wxList::Sort(const wxSortCompareFunction compfunc)
-{
- // allocate an array for the wxObject pointers of the list
- const size_t num = Number();
- wxObject **objArray = new wxObject *[num];
- wxObject **objPtr = objArray;
-
- // go through the list and put the pointers into the array
- wxNode *node = First();
- while(node!=NULL){
- *objPtr++ = node->Data();
- node = node->Next();
- }
- // sort the array
- qsort((void *)objArray,num,sizeof(wxObject *),compfunc);
- // put the sorted pointers back into the list
- objPtr = objArray;
- node = First();
- while(node!=NULL){
- node->SetData(*objPtr++);
- node = node->Next();
- }
- // free the array
- delete[] objArray;
+void wxListBase::Sort(const wxSortCompareFunction compfunc)
+{
+ // allocate an array for the wxObject pointers of the list
+ const size_t num = GetCount();
+ void **objArray = new void *[num];
+ void **objPtr = objArray;
+
+ // go through the list and put the pointers into the array
+ wxNodeBase *node;
+ for ( node = GetFirst(); node; node = node->Next() )
+ {
+ *objPtr++ = node->Data();
+ }
+
+ // sort the array
+ qsort((void *)objArray,num,sizeof(wxObject *),compfunc);
+
+ // put the sorted pointers back into the list
+ objPtr = objArray;
+ for ( node = GetFirst(); node; node = node->Next() )
+ {
+ node->SetData(*objPtr++);
+ }
+
+ // free the array
+ delete[] objArray;
+}
+
+// -----------------------------------------------------------------------------
+// wxList (a.k.a. wxObjectList)
+// -----------------------------------------------------------------------------
+
+void wxObjectListNode::DeleteData()
+{
+ delete (wxObject *)GetData();
}
-/*
- * String list
- *
- */
+// -----------------------------------------------------------------------------
+// wxStringList
+// -----------------------------------------------------------------------------
-wxStringList::wxStringList (void):
-wxList ()
+// instead of WX_DEFINE_LIST(wxStringListBase) we define this function
+// ourselves
+void wxStringListNode::DeleteData()
{
+ delete [] (char *)GetData();
+}
+
+bool wxStringList::Delete(const char *s)
+{
+ wxStringListNode *current;
+
+ for ( current = GetFirst(); current; current = current->GetNext() )
+ {
+ if ( strcmp(current->GetData(), s) == 0 )
+ {
+ DeleteNode(current);
+ return TRUE;
+ }
+ }
+
+ // not found
+ return FALSE;
+}
+
+void wxStringList::DoCopy(const wxStringList& other)
+{
+ wxASSERT( GetCount() == 0 ); // this list must be empty before copying!
+
+ size_t count = other.GetCount();
+ for ( size_t n = 0; n < count; n++ )
+ {
+ Add(other.Item(n)->GetData());
+ }
}
// Variable argument list, terminated by a zero
// Makes new storage for the strings
-wxStringList::wxStringList (const char *first...)
+wxStringList::wxStringList (const char *first, ...)
{
-// #ifndef __SGI__
- n = 0;
- destroy_data = 0;
- key_type = wxKEY_NONE;
- first_node = NULL;
- last_node = NULL;
-
- if (!first)
+ if ( !first )
return;
va_list ap;
+ va_start(ap, first);
- va_start (ap, first);
-
- wxNode *last = new wxNode (this, NULL, NULL, (wxObject *) copystring (first));
- first_node = last;
- n = 1;
-
+ const char *s = first;
for (;;)
- {
- char *s = va_arg (ap, char *);
-// if (s == NULL)
+ {
+ Add(s);
+
+ s = va_arg(ap, const char *);
+ // if (s == NULL)
#ifdef __WXMSW__
if ((int) s == 0)
#else
if ((long) s == 0)
#endif
- break;
- else
- {
- wxNode *node = new wxNode (this, last, NULL, (wxObject *) copystring (s));
- last = node;
- n++;
- }
- }
- last_node = last;
- va_end (ap);
-/*
-#else
- fprintf (stderr, "Error: cannot use variable-argument functions on SGI!\n");
-#endif
-*/
-}
-
-wxStringList::~wxStringList (void)
-{
- wxNode *each = first_node;
- while (each)
- {
- char *s = (char *) each->Data ();
- delete[]s;
- wxNode *next = each->Next ();
- delete each;
- each = next;
- }
-}
+ break;
+ }
-wxNode *wxStringList::Add (const char *s)
-{
- return Append ((wxObject *) (copystring (s)));
+ va_end(ap);
}
-void wxStringList::Delete (const char *s)
+// Only makes new strings if arg is TRUE
+char **wxStringList::ListToArray(bool new_copies) const
{
- for (wxNode * node = First (); node; node = node->Next ())
+ char **string_array = new char *[GetCount()];
+ wxStringListNode *node = GetFirst();
+ for (size_t i = 0; i < GetCount(); i++)
{
- char *string = (char *) node->Data ();
- if (string == s || strcmp (string, s) == 0)
- {
- delete[]string;
- delete node;
- break; // Done!
-
- }
- } // for
+ char *s = node->GetData();
+ if ( new_copies )
+ string_array[i] = copystring(s);
+ else
+ string_array[i] = s;
+ node = node->GetNext();
+ }
+ return string_array;
}
-// Only makes new strings if arg is TRUE
-char **wxStringList::ListToArray (bool new_copies) const
+// Checks whether s is a member of the list
+bool wxStringList::Member(const char *s) const
{
- char **string_array = new char *[Number ()];
- wxNode *node = First ();
- int i;
- for (i = 0; i < n; i++)
+ for ( wxStringListNode *node = GetFirst(); node; node = node->GetNext() )
{
- char *s = (char *) node->Data ();
- if (new_copies)
- string_array[i] = copystring (s);
- else
- string_array[i] = s;
- node = node->Next ();
+ const char *s1 = node->GetData();
+ if (s == s1 || strcmp (s, s1) == 0)
+ return TRUE;
}
- return string_array;
+
+ return FALSE;
}
-static int
-wx_comparestrings (const void *arg1, const void *arg2)
+static int
+wx_comparestrings(const void *arg1, const void *arg2)
{
char **s1 = (char **) arg1;
char **s2 = (char **) arg2;
}
// Sort a list of strings - deallocates old nodes, allocates new
-void wxStringList::Sort (void)
+void wxStringList::Sort()
{
- size_t N = n;
- char **array = new char *[N];
-
- size_t i = 0;
- for (wxNode * node = First (); node; node = node->Next ())
- array[i++] = (char *) node->Data ();
+ size_t N = GetCount();
+ char **array = new char *[N];
+ wxStringListNode *node;
- qsort (array, N, sizeof (char *), wx_comparestrings);
- Clear ();
+ size_t i = 0;
+ for ( node = GetFirst(); node; node = node->GetNext() )
+ {
+ array[i++] = node->GetData();
+ }
- for (i = 0; i < N; i++)
- Append ((wxObject *) (array[i]));
+ qsort (array, N, sizeof (char *), wx_comparestrings);
- delete[]array;
-}
+ i = 0;
+ for ( node = GetFirst(); node; node = node->GetNext() )
+ node->SetData( array[i++] );
-// Checks whether s is a member of the list
-bool wxStringList::Member (const char *s) const
-{
- for (wxNode * node = First (); node; node = node->Next ())
- {
- const char *s1 = (const char *) node->Data ();
- if (s == s1 || strcmp (s, s1) == 0)
- return TRUE;
- }
- return FALSE;
+ delete [] array;
}
projects / wxWidgets.git / blobdiff