// Created: 29/01/98
// RCS-ID: $Id$
// Copyright: (c) 1998 Julian Smart
-// Licence: wxWindows license
+// Licence: wxWindows license
/////////////////////////////////////////////////////////////////////////////
/*
long GetNumber() const
{ wxASSERT( m_keyType == wxKEY_INTEGER ); return m_key.integer; }
- // comparaison
- bool operator==(wxListKeyValue value) const
- {
- switch ( m_keyType )
- {
- default:
- wxFAIL_MSG("bad key type.");
- // let compiler optimize the line above away in release build
- // by not putting return here...
-
- case wxKEY_STRING:
- return strcmp(m_key.string, value.string) == 0;
-
- case wxKEY_INTEGER:
- return m_key.integer == value.integer;
- }
- }
+ // comparison
+ // Note: implementation moved to list.cpp to prevent BC++ inline
+ // expansion warning.
+ bool operator==(wxListKeyValue value) const ;
// dtor
~wxListKey()
// @@ no check is done that the list is really keyed on strings
const char *GetKeyString() const { return m_key.string; }
+ long GetKeyInteger() const { return m_key.integer; }
+
+ // Necessary for some existing code
+ void SetKeyString(char* s) { m_key.string = s; }
+ void SetKeyInteger(long i) { m_key.integer = i; }
#ifdef wxLIST_COMPATIBILITY
// compatibility methods
void *GetData() const { return m_data; }
void SetData(void *data) { m_data = data; }
+ // get 0-based index of this node within the list or NOT_FOUND
+ int IndexOf() const;
+
virtual void DeleteData() { }
private:
size_t GetCount() const { return m_count; }
// operations
+
// delete all nodes
- virtual void Clear();
+ void Clear();
+
// instruct it to destroy user data when deleting nodes
void DeleteContents(bool destroy) { m_destroy = destroy; }
+ // query if to delete
+ bool GetDeleteContents() const
+ { return m_destroy; }
+
+ // get the keytype
+ wxKeyType GetKeyType() const
+ { return m_keyType; }
+
+ // set the keytype (required by the serial code)
+ void SetKeyType(wxKeyType keyType)
+ { wxASSERT( m_count==0 ); m_keyType = keyType; }
+
protected:
// all methods here are "overloaded" in derived classes to provide compile
// time type checking
// get the list item's data
void *operator[](size_t index) const
- { wxNodeBase *node = Item(index); return node ? node->GetData() : NULL; }
+ { wxNodeBase *node = Item(index); return node ? node->GetData() : (wxNodeBase*)NULL; }
// operations
// append to end of list
wxNodeBase *Append(void *object);
// insert a new item at the beginning of the list
- wxNodeBase *Insert(void *object) { return Insert(NULL, object); }
+ wxNodeBase *Insert(void *object) { return Insert( (wxNodeBase*)NULL, object); }
// insert before given node or at front of list if prev == NULL
wxNodeBase *Insert(wxNodeBase *prev, void *object);
bool DeleteNode(wxNodeBase *node);
// finds object pointer and deletes node (and object if DeleteContents
// is on), returns FALSE if object not found
- bool DeleteObject(void *object);
+ bool DeleteObject(void *object);
// search (all return NULL if item not found)
// by data
// by key
wxNodeBase *Find(const wxListKey& key) const;
+ // get 0-based index of object or NOT_FOUND
+ int IndexOf( void *object ) const;
+
// this function allows the sorting of arbitrary lists by giving
// a function to compare two list elements. The list is sorted in place.
- void Sort(wxSortCompareFunction compfunc);
+ void Sort(const wxSortCompareFunction compfunc);
// functions for iterating over the list
void *FirstThat(wxListIterateFunction func);
void ForEach(wxListIterateFunction func);
void *LastThat(wxListIterateFunction func);
-
+
private:
// helpers
// common part of all ctors
- void Init(wxKeyType keyType);
+ void Init(wxKeyType keyType = wxKEY_NONE);
// common part of copy ctor and assignment operator
void DoCopy(const wxListBase& list);
// common part of all Append()s
nodetype *Append(T *object) \
{ return (nodetype *)wxListBase::Append(object); } \
nodetype *Insert(T *object) \
- { return (nodetype *)Insert(NULL, object); } \
+ { return (nodetype *)Insert((nodetype*)NULL, object); } \
nodetype *Insert(nodetype *prev, T *object) \
{ return (nodetype *)wxListBase::Insert(prev, object); } \
\
virtual nodetype *Find(const wxListKey& key) const \
{ return (nodetype *)wxListBase::Find(key); } \
\
+ int IndexOf( T *object ) const \
+ { return wxListBase::IndexOf(object); } \
+ \
void Sort(wxSortFuncFor_##name func) \
{ wxListBase::Sort((wxSortCompareFunction)func); } \
\
// -----------------------------------------------------------------------------
// wxStringList class for compatibility with the old code
// -----------------------------------------------------------------------------
-
+
WX_DECLARE_LIST_2(char, wxStringListBase, wxStringListNode);
class WXDLLEXPORT wxStringList : public wxStringListBase
wxStringList() { DeleteContents(TRUE); }
wxStringList(const char *first ...);
+ // copying the string list: the strings are copied, too (extremely
+ // inefficient!)
+ wxStringList(const wxStringList& other) { DoCopy(other); }
+ wxStringList& operator=(const wxStringList& other)
+ { Clear(); DoCopy(other); return *this; }
+
// operations
// makes a copy of the string
wxNode *Add(const char *s)
{ return (wxNode *)wxStringListBase::Append(copystring(s)); }
- void Delete(const char *s)
- { wxStringListBase::DeleteObject((char *)s); }
+ bool Delete(const char *s);
char **ListToArray(bool new_copies = FALSE) const;
bool Member(const char *s) const;
wxNode *First() const { return (wxNode *)GetFirst(); }
wxNode *Last() const { return (wxNode *)GetLast(); }
wxNode *Nth(size_t index) const { return (wxNode *)Item(index); }
+
+private:
+ void DoCopy(const wxStringList&); // common part of copy ctor and operator=
};
#endif // wxLIST_COMPATIBILITY
projects / wxWidgets.git / blobdiff