Amebis/wxWidgets
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

1. new wxList code

Browse Source 
2. fixes to allow compilation at -W4 with VisualC++ 6.0


git-svn-id: https://svn.wxwidgets.org/svn/wx/wxWidgets/trunk@1035 c3d73ce0-8a6f-49c7-b76d-6d57e0e08775
This commit is contained in:
Vadim Zeitlin
1998-11-24 23:30:50 +00:00
parent 621793f45e
commit fd3f686c27
50 changed files with 1635 additions and 1431 deletions
Download Patch File Download Diff File Expand all files Collapse all files

533
include/wx/list.h
View File

@@ -2,13 +2,26 @@
// Name: list.h
// Purpose: wxList, wxStringList classes
// Author: Julian Smart
// Modified by:
// Modified by: VZ at 16/11/98: WX_DECLARE_LIST() and typesafe lists added
// Created: 29/01/98
// RCS-ID: $Id$
// Copyright: (c) 1998 Julian Smart
// Licence: wxWindows license
/////////////////////////////////////////////////////////////////////////////
/*
All this is quite ugly but serves two purposes:
1. Be almost 100% compatible with old, untyped, wxList class
2. Ensure compile-time type checking for the linked lists
The idea is to have one base class (wxListBase) working with "void *" data,
but to hide these untyped functions - i.e. make them protected, so they
can only be used from derived classes which have inline member functions
working with right types. This achieves the 2nd goal. As for the first one,
we provide a special derivation of wxListBase called wxList which looks just
like the old class.
*/
#ifndef _WX_LISTH__
#define _WX_LISTH__
@@ -16,133 +29,445 @@
#pragma interface "list.h"
#endif
// -----------------------------------------------------------------------------
// headers
// -----------------------------------------------------------------------------
#include "wx/defs.h"
#include "wx/debug.h"
#include "wx/object.h"
class WXDLLEXPORT wxList;
// due to circular header dependencies this function has to be declared here
// (normally it's found in utils.h which includes itself list.h...)
extern char* WXDLLEXPORT copystring(const char *s);
#define wxKEY_NONE 0
#define wxKEY_INTEGER 1
#define wxKEY_STRING 2
class WXDLLEXPORT wxNode: public wxObject
class WXDLLEXPORT wxObjectListNode;
typedef wxObjectListNode wxNode;
// undef it to get rid of old, deprecated functions
#define wxLIST_COMPATIBILITY
// -----------------------------------------------------------------------------
// constants
// -----------------------------------------------------------------------------
enum wxKeyType
{
DECLARE_DYNAMIC_CLASS(wxNode)
private:
wxObject *data;
wxNode *next;
wxNode *previous;
wxKEY_NONE,
wxKEY_INTEGER,
wxKEY_STRING
};
public:
wxList *list;
// -----------------------------------------------------------------------------
// types
// -----------------------------------------------------------------------------
// Optional key stuff
union
{
// type of compare function for list sort operation (as in 'qsort'): it should
// return a negative value, 0 or positive value if the first element is less
// than, equal or greater than the second
typedef int (*wxSortCompareFunction)(const void *elem1, const void *elem2);
//
typedef int (*wxListIterateFunction)(void *current);
// -----------------------------------------------------------------------------
// key stuff: a list may be optionally keyed on integer or string key
// -----------------------------------------------------------------------------
union wxListKeyValue
{
long integer;
char *string;
} key;
wxNode(wxList *the_list = (wxList *) NULL, wxNode *last_one = (wxNode *) NULL, wxNode *next_one = (wxNode *) NULL, wxObject *object = (wxObject *) NULL);
wxNode(wxList *the_list, wxNode *last_one, wxNode *next_one,
wxObject *object, long the_key);
wxNode(wxList *the_list, wxNode *last_one, wxNode *next_one,
wxObject *object, const char *the_key);
~wxNode(void);
inline wxNode *Next(void) const { return next; }
inline wxNode *Previous(void) const { return previous; }
inline wxObject *Data(void) const { return (wxObject *)data; }
inline void SetData(wxObject *the_data) { data = the_data; }
};
// type of compare function for list sort operation (as in 'qsort')
typedef int (*wxSortCompareFunction)(const void *elem1, const void *elem2);
typedef int (*wxListIterateFunction)(wxObject *o);
class WXDLLEXPORT wxList: public wxObject
// a struct which may contain both types of keys
//
// implementation note: on one hand, this class allows to have only one function
// for any keyed operation instead of 2 almost equivalent. OTOH, it's needed to
// resolve ambiguity which we would otherwise have with wxStringList::Find() and
// wxList::Find(const char *).
class WXDLLEXPORT wxListKey
{
DECLARE_DYNAMIC_CLASS(wxList)
public:
// implicit ctors
wxListKey()
{ m_keyType = wxKEY_NONE; }
wxListKey(long i)
{ m_keyType = wxKEY_INTEGER; m_key.integer = i; }
wxListKey(const char *s)
{ m_keyType = wxKEY_STRING; m_key.string = strdup(s); }
wxListKey(const wxString& s)
{ m_keyType = wxKEY_STRING; m_key.string = strdup(s.c_str()); }
public:
int n;
int destroy_data;
wxNode *first_node;
wxNode *last_node;
unsigned int key_type;
// accessors
wxKeyType GetKeyType() const { return m_keyType; }
const char *GetString() const
{ wxASSERT( m_keyType == wxKEY_STRING ); return m_key.string; }
long GetNumber() const
{ wxASSERT( m_keyType == wxKEY_INTEGER ); return m_key.integer; }
wxList(void);
wxList(const unsigned int the_key_type);
wxList(int N, wxObject *Objects[]);
wxList(wxObject *object, ...);
~wxList(void);
// 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...
inline int Number(void) const { return n; }
inline int GetCount(void) const { return n; }
case wxKEY_STRING:
return strcmp(m_key.string, value.string) == 0;
// Append to end of list
wxNode *Append(wxObject *object);
case wxKEY_INTEGER:
return m_key.integer == value.integer;
}
}
// Insert at front of list
wxNode *Insert(wxObject *object);
// dtor
~wxListKey()
{
if ( m_keyType == wxKEY_STRING )
free(m_key.string);
}
// Insert before given node
wxNode *Insert(wxNode *position, wxObject *object);
// Keyed append
wxNode *Append(long key, wxObject *object);
wxNode *Append(const char *key, wxObject *object);
bool DeleteNode(wxNode *node);
bool DeleteObject(wxObject *object); // Finds object pointer and
// deletes node (and object if
// DeleteContents is on)
virtual void Clear(void); // Delete all nodes
inline wxNode *First(void) const { return first_node; }
inline wxNode *Last(void) const { return last_node; }
wxNode *Nth(int i) const; // nth node counting from 0
// Keyed search
virtual wxNode *Find(long key) const;
virtual wxNode *Find(const char *key) const;
virtual wxNode *Member(wxObject *object) const;
inline void DeleteContents(int destroy) { destroy_data = destroy; }
// Instruct it to destroy user data
// when deleting nodes
// this function allows the sorting of arbitrary lists by giving
// a function to compare two list elements.
void Sort(const wxSortCompareFunction compfunc);
wxObject *FirstThat(wxListIterateFunction func);
void ForEach(wxListIterateFunction func);
wxObject *LastThat(wxListIterateFunction func);
private:
wxKeyType m_keyType;
wxListKeyValue m_key;
};
// String list class. N.B. this always copies strings
// with Add and deletes them itself.
class WXDLLEXPORT wxStringList: public wxList
// -----------------------------------------------------------------------------
// wxNodeBase class is a (base for) node in a double linked list
// -----------------------------------------------------------------------------
class WXDLLEXPORT wxNodeBase
{
DECLARE_DYNAMIC_CLASS(wxStringList)
friend class wxListBase;
public:
// ctor
wxNodeBase(wxListBase *list = (wxListBase *)NULL,
wxNodeBase *previous = (wxNodeBase *)NULL,
wxNodeBase *next = (wxNodeBase *)NULL,
void *data = NULL,
const wxListKey& key = wxListKey());
public:
wxStringList(void);
wxStringList(const wxStringList& list);
wxStringList(const char *first ...);
~wxStringList(void);
virtual ~wxNodeBase();
virtual wxNode *Add(const char *s);
virtual void Delete(const char *s);
virtual char **ListToArray(bool new_copies = FALSE) const;
virtual void Sort(void);
virtual bool Member(const char *s) const;
virtual void Clear(void);
void operator= (const wxStringList& list);
char* operator[] (int i) const;
// @@ no check is done that the list is really keyed on strings
const char *GetKeyString() const { return m_key.string; }
#ifdef wxLIST_COMPATIBILITY
// compatibility methods
wxNode *Next() const { return (wxNode *)GetNext(); }
wxNode *Previous() const { return (wxNode *)GetPrevious(); }
wxObject *Data() const { return (wxObject *)GetData(); }
#endif // wxLIST_COMPATIBILITY
protected:
// all these are going to be "overloaded" in the derived classes
wxNodeBase *GetNext() const { return m_next; }
wxNodeBase *GetPrevious() const { return m_previous; }
void *GetData() const { return m_data; }
void SetData(void *data) { m_data = data; }
virtual void DeleteData() { }
private:
// optional key stuff
wxListKeyValue m_key;
void *m_data; // user data
wxNodeBase *m_next, // next and previous nodes in the list
*m_previous;
wxListBase *m_list; // list we belong to
};
// -----------------------------------------------------------------------------
// a double-linked list class
// -----------------------------------------------------------------------------
class WXDLLEXPORT wxListBase : public wxObject
{
friend class wxNodeBase; // should be able to call DetachNode()
public:
// default ctor & dtor
wxListBase(wxKeyType keyType = wxKEY_NONE) { Init(keyType); }
virtual ~wxListBase();
// accessors
// count of items in the list
size_t GetCount() const { return m_count; }
// operations
// delete all nodes
virtual void Clear();
// instruct it to destroy user data when deleting nodes
void DeleteContents(bool destroy) { m_destroy = destroy; }
protected:
// all methods here are "overloaded" in derived classes to provide compile
// time type checking
// create a node for the list of this type
virtual wxNodeBase *CreateNode(wxNodeBase *prev, wxNodeBase *next,
void *data,
const wxListKey& key = wxListKey()) = 0;
// ctors
// from an array
wxListBase(size_t count, void *elements[]);
// from a sequence of objects
wxListBase(void *object, ... /* terminate with NULL */);
// copy ctor and assignment operator
wxListBase(const wxListBase& list)
{ DoCopy(list); }
wxListBase& operator=(const wxListBase& list)
{ Clear(); DoCopy(list); return *this; }
// get list head/tail
wxNodeBase *GetFirst() const { return m_nodeFirst; }
wxNodeBase *GetLast() const { return m_nodeLast; }
// by (0-based) index
wxNodeBase *Item(size_t index) const;
// get the list item's data
void *operator[](size_t index) const
{ wxNodeBase *node = Item(index); return node ? node->GetData() : 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); }
// insert before given node or at front of list if prev == NULL
wxNodeBase *Insert(wxNodeBase *prev, void *object);
// keyed append
wxNodeBase *Append(long key, void *object);
wxNodeBase *Append(const char *key, void *object);
// removes node from the list but doesn't delete it (returns pointer
// to the node or NULL if it wasn't found in the list)
wxNodeBase *DetachNode(wxNodeBase *node);
// delete element from list, returns FALSE if node not found
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);
// search (all return NULL if item not found)
// by data
wxNodeBase *Find(void *object) const;
// by key
wxNodeBase *Find(const wxListKey& key) 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);
// 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);
// common part of copy ctor and assignment operator
void DoCopy(const wxListBase& list);
// common part of all Append()s
wxNodeBase *AppendCommon(wxNodeBase *node);
// free node's data and node itself
void DoDeleteNode(wxNodeBase *node);
size_t m_count; // number of elements in the list
bool m_destroy; // destroy user data when deleting list items?
wxNodeBase *m_nodeFirst, // pointers to the head and tail of the list
*m_nodeLast;
wxKeyType m_keyType; // type of our keys (may be wxKEY_NONE)
};
// -----------------------------------------------------------------------------
// macros for definition of "template" list type
// -----------------------------------------------------------------------------
// and now some heavy magic...
// declare a list type named 'name' and containing elements of type 'T *'
// (as a by product of macro expansion you also get wx##name##Node
// wxNode-dervied type)
//
// implementation details:
// 1. we define _WX_LIST_ITEM_TYPE_##name typedef to save in it the item type
// for the list of given type - this allows us to pass only the list name
// to WX_DEFINE_LIST() even if it needs both the name and the type
//
// 2. We redefine all not type-safe wxList functions withtype-safe versions
// which don't take any place (everything is inline), but bring compile
// time error checking.
#define WX_DECLARE_LIST_2(T, name, nodetype) \
typedef int (*wxSortFuncFor_##name)(const T *, const T *); \
\
class WXDLLEXPORT nodetype : public wxNodeBase \
{ \
public: \
nodetype(wxListBase *list = (wxListBase *)NULL, \
nodetype *previous = (nodetype *)NULL, \
nodetype *next = (nodetype *)NULL, \
T *data = NULL, \
const wxListKey& key = wxListKey()) \
: wxNodeBase(list, previous, next, data, key) { } \
\
nodetype *GetNext() const \
{ return (nodetype *)wxNodeBase::GetNext(); } \
nodetype *GetPrevious() const \
{ return (nodetype *)wxNodeBase::GetPrevious(); } \
\
T *GetData() const \
{ return (T *)wxNodeBase::GetData(); } \
void SetData(T *data) \
{ wxNodeBase::SetData(data); } \
\
virtual void DeleteData(); \
}; \
\
class name : public wxListBase \
{ \
public: \
name(wxKeyType keyType = wxKEY_NONE) : wxListBase(keyType) \
{ } \
name(size_t count, T *elements[]) \
: wxListBase(count, (void **)elements) { } \
\
nodetype *GetFirst() const \
{ return (nodetype *)wxListBase::GetFirst(); } \
nodetype *GetLast() const \
{ return (nodetype *)wxListBase::GetLast(); } \
\
nodetype *Item(size_t index) const \
{ return (nodetype *)wxListBase::Item(index); } \
\
T *operator[](size_t index) const \
{ \
nodetype *node = Item(index); \
return node ? node->GetData() : NULL; \
} \
\
nodetype *Append(T *object) \
{ return (nodetype *)wxListBase::Append(object); } \
nodetype *Insert(T *object) \
{ return (nodetype *)Insert(NULL, object); } \
nodetype *Insert(nodetype *prev, T *object) \
{ return (nodetype *)wxListBase::Insert(prev, object); } \
\
nodetype *Append(long key, void *object) \
{ return (nodetype *)wxListBase::Append(key, object); } \
nodetype *Append(const char *key, void *object) \
{ return (nodetype *)wxListBase::Append(key, object); } \
\
nodetype *DetachNode(nodetype *node) \
{ return (nodetype *)wxListBase::DetachNode(node); } \
bool DeleteNode(nodetype *node) \
{ return wxListBase::DeleteNode(node); } \
bool DeleteObject(T *object) \
{ return wxListBase::DeleteObject(object); } \
\
nodetype *Find(T *object) const \
{ return (nodetype *)wxListBase::Find(object); } \
\
virtual nodetype *Find(const wxListKey& key) const \
{ return (nodetype *)wxListBase::Find(key); } \
\
void Sort(wxSortFuncFor_##name func) \
{ wxListBase::Sort((wxSortCompareFunction)func); } \
\
protected: \
wxNodeBase *CreateNode(wxNodeBase *prev, wxNodeBase *next, \
void *data, \
const wxListKey& key = wxListKey()) \
{ \
return new nodetype(this, \
(nodetype *)prev, (nodetype *)next, \
(T *)data, key); \
} \
}
#define WX_DECLARE_LIST(elementtype, listname) \
typedef elementtype _WX_LIST_ITEM_TYPE_##listname; \
WX_DECLARE_LIST_2(elementtype, listname, wx##listname##Node)
// this macro must be inserted in your program after
// #include <wx/listimpl.cpp>
#define WX_DEFINE_LIST(name) "don't forget to include listimpl.cpp!"
// =============================================================================
// now we can define classes 100% compatible with the old ones
// =============================================================================
#ifdef wxLIST_COMPATIBILITY
// -----------------------------------------------------------------------------
// wxList compatibility class: in fact, it's a list of wxObjects
// -----------------------------------------------------------------------------
WX_DECLARE_LIST_2(wxObject, wxObjectList, wxObjectListNode);
class WXDLLEXPORT wxList : public wxObjectList
{
public:
wxList(int key_type = wxKEY_NONE) : wxObjectList((wxKeyType)key_type) { }
// compatibility methods
int Number() const { return GetCount(); }
wxNode *First() const { return (wxNode *)GetFirst(); }
wxNode *Last() const { return (wxNode *)GetLast(); }
wxNode *Nth(size_t index) const { return (wxNode *)Item(index); }
wxNode *Member(wxObject *object) const { return (wxNode *)Find(object); }
};
// -----------------------------------------------------------------------------
// wxStringList class for compatibility with the old code
// -----------------------------------------------------------------------------
WX_DECLARE_LIST_2(char, wxStringListBase, wxStringListNode);
class WXDLLEXPORT wxStringList : public wxStringListBase
{
public:
// ctors and such
// default
wxStringList() { DeleteContents(TRUE); }
wxStringList(const char *first ...);
// 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); }
char **ListToArray(bool new_copies = FALSE) const;
bool Member(const char *s) const;
// alphabetic sort
void Sort();
// compatibility methods
int Number() const { return GetCount(); }
wxNode *First() const { return (wxNode *)GetFirst(); }
wxNode *Last() const { return (wxNode *)GetLast(); }
wxNode *Nth(size_t index) const { return (wxNode *)Item(index); }
};
#endif // wxLIST_COMPATIBILITY
#endif
// _WX_LISTH__