#ifndef _WX_LISTH__
#define _WX_LISTH__
-#if defined(__GNUG__) && !defined(__APPLE__) && \
+#if defined(__GNUG__) && !defined(NO_GCC_PRAGMA) && \
!(defined(__MINGW32__) && __GNUC__ == 3 && __GNUC_MINOR__ == 2)
#pragma interface "list.h"
#endif
#include "wx/beforestd.h"
#include <list>
#include "wx/afterstd.h"
- #if defined(__WXMSW__) && defined(__MINGW32__)
- #include "wx/msw/winundef.h"
- #endif
#endif
// ----------------------------------------------------------------------------
// 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
+
extern "C"
{
typedef int (* LINKAGEMODE wxSortCompareFunction)(const void *elem1, const void *elem2);
#define wxLIST_COMPATIBILITY
#define WX_DECLARE_LIST_3(elT, dummy1, liT, dummy2, decl) \
- WX_DECLARE_LIST_X(elT, liT, decl)
+ WX_DECLARE_LIST_WITH_DECL(elT, liT, decl)
+#define WX_DECLARE_LIST_PTR_3(elT, dummy1, liT, dummy2, decl) \
+ WX_DECLARE_LIST_3(elT, dummy1, liT, dummy2, decl)
#define WX_DECLARE_LIST_2(elT, liT, dummy, decl) \
- WX_DECLARE_LIST_X(elT, liT, decl)
+ WX_DECLARE_LIST_WITH_DECL(elT, liT, decl)
+#define WX_DECLARE_LIST_PTR_2(elT, liT, dummy, decl) \
+ WX_DECLARE_LIST_2(elT, liT, dummy, decl) \
-#define WX_DECLARE_LIST_X(elT, liT, decl) \
+#define WX_DECLARE_LIST_WITH_DECL(elT, liT, decl) \
WX_DECLARE_LIST_XO(elT*, liT, decl)
#define WX_DECLARE_LIST_XO(elT, liT, decl) \
compatibility_iterator() : m_list( NULL ) { } \
dummy* operator->() { return (dummy*)this; } \
const dummy* operator->() const { return (const dummy*)this; } \
+ bool operator==(const compatibility_iterator& it) \
+ { return m_list == it.m_list && m_iter == it.m_iter; } \
+ bool operator!=(const compatibility_iterator& it) \
+ { return m_list != it.m_list || m_iter != it.m_iter; } \
}; \
typedef struct compatibility_iterator citer; \
\
{ \
citer* i = (citer*)this; \
it lit = i->m_iter; \
- return citer( i->m_list, ++lit ); \
+ return citer( i->m_list, --lit ); \
} \
void SetData( elT e ) \
{ \
dummy(); \
}; \
protected: \
- iterator find( elT e ) \
+ iterator find( const elT e ) \
{ \
iterator it, en; \
for( it = begin(), en = end(); it != en; ++it ) \
return it; \
} \
public: \
- liT() {}; \
+ liT() {} \
\
citer Append( elT e ) { push_back( e ); return GetLast(); } \
void Clear() { clear(); } \
{ \
erase( it.m_iter ); \
} \
- citer Find( elT e ) const { return citer( this, ((liT*)this)->find( e ) ); } \
+ citer Find( const elT e ) const { return citer( this, ((liT*)this)->find( e ) ); } \
citer Member( elT e ) const { return Find( e ); } \
citer Insert( elT e ) \
{ push_front( e ); return citer( this, begin() ); } \
}
#define WX_DECLARE_LIST(elementtype, listname) \
- WX_DECLARE_LIST_X(elementtype, listname, class)
+ WX_DECLARE_LIST_WITH_DECL(elementtype, listname, class)
+#define WX_DECLARE_LIST_PTR(elementtype, listname) \
+ WX_DECLARE_LIST(elementtype, listname)
#define WX_DECLARE_EXPORTED_LIST(elementtype, listname) \
- WX_DECLARE_LIST_X(elementtype, listname, class WXDLLEXPORT)
+ WX_DECLARE_LIST_WITH_DECL(elementtype, listname, class WXDLLEXPORT)
+#define WX_DECLARE_EXPORTED_LIST_PTR(elementtype, listname) \
+ WX_DECLARE_EXPORTED_LIST(elementtype, listname)
#define WX_DECLARE_USER_EXPORTED_LIST(elementtype, listname, usergoo) \
- WX_DECLARE_LIST_X(elementtype, listname, class usergoo)
+ WX_DECLARE_LIST_WITH_DECL(elementtype, listname, class usergoo)
+#define WX_DECLARE_USER_EXPORTED_LIST_PTR(elementtype, listname, usergoo) \
+ WX_DECLARE_USER_EXPORTED_LIST(elementtype, listname, usergoo)
// this macro must be inserted in your program after
// #include <wx/listimpl.cpp>
// 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 WXDLLEXPORT wxChar* copystring(const wxChar *s);
+#if WXWIN_COMPATIBILITY_2_4
+extern WXDLLIMPEXP_BASE wxChar* copystring(const wxChar *s);
+#endif
class WXDLLEXPORT wxObjectListNode;
typedef wxObjectListNode wxNode;
// wxNodeBase class is a (base for) node in a double linked list
// -----------------------------------------------------------------------------
-WXDLLIMPEXP_DATA_BASE(extern wxListKey) wxDefaultListKey;
+extern WXDLLIMPEXP_DATA_BASE(wxListKey) wxDefaultListKey;
class WXDLLIMPEXP_BASE wxListBase;
// a double-linked list class
// -----------------------------------------------------------------------------
-class wxList;
+class WXDLLIMPEXP_BASE wxList;
class WXDLLIMPEXP_BASE wxListBase : public wxObject
{
// count of items in the list
size_t GetCount() const { return m_count; }
- // return TRUE if this list is empty
+ // return true if this list is empty
bool IsEmpty() const { return m_count == 0; }
// operations
wxListBase(void *object, ... /* terminate with NULL */);
protected:
- // copy ctor and assignment operator
- wxListBase(const wxListBase& list) : wxObject()
- { Init(); DoCopy(list); }
- wxListBase& operator=(const wxListBase& list)
- { Clear(); DoCopy(list); return *this; }
+ void Assign(const wxListBase& list)
+ { Clear(); DoCopy(list); }
// get list head/tail
wxNodeBase *GetFirst() const { return m_nodeFirst; }
// 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
+ // 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
+ // 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;
+ wxNodeBase *Find(const void *object) const;
// by key
wxNodeBase *Find(const wxListKey& key) const;
// particularly useful with, for example, "wxWindow *" list where the
// wxWindowBase pointers are put into the list, but wxWindow pointers are
// retrieved from it.
+//
+// 4. final hack is that WX_DECLARE_LIST_3 is defined in terms of
+// WX_DECLARE_LIST_4 to allow defining classes without operator->() as
+// it results in compiler warnings when this operator doesn't make sense
+// (i.e. stored elements are not pointers)
-#define WX_DECLARE_LIST_3(T, Tbase, name, nodetype, classexp) \
+// common part of WX_DECLARE_LIST_3 and WX_DECLARE_LIST_PTR_3
+#define WX_DECLARE_LIST_4(T, Tbase, name, nodetype, classexp, ptrop) \
typedef int (*wxSortFuncFor_##name)(const T **, const T **); \
\
classexp nodetype : public wxNodeBase \
{ wxNodeBase::SetData(data); } \
\
virtual void DeleteData(); \
+ \
+ DECLARE_NO_COPY_CLASS(nodetype) \
}; \
\
classexp name : public wxListBase \
\
name(wxKeyType keyType = wxKEY_NONE) : wxListBase(keyType) \
{ } \
+ name(const name& list) : wxListBase(list.GetKeyType()) \
+ { Assign(list); } \
name(size_t count, T *elements[]) \
: wxListBase(count, (void **)elements) { } \
\
name& operator=(const name& list) \
- { (void) wxListBase::operator=(list); return *this; } \
+ { Assign(list); return *this; } \
\
nodetype *GetFirst() const \
{ return (nodetype *)wxListBase::GetFirst(); } \
void Erase(compatibility_iterator it) \
{ DeleteNode(it); } \
\
- nodetype *Find(Tbase *object) const \
+ nodetype *Find(const Tbase *object) const \
{ return (nodetype *)wxListBase::Find(object); } \
\
virtual nodetype *Find(const wxListKey& key) const \
{ \
typedef name list; \
public: \
- typedef list::Node Node; \
+ typedef nodetype Node; \
typedef iterator itor; \
- typedef list::value_type* ptr_type; \
+ typedef T* value_type; \
+ typedef value_type* ptr_type; \
+ typedef value_type& reference; \
\
Node* m_node; \
Node* m_init; \
public: \
- typedef list::reference reference_type; \
+ typedef reference reference_type; \
typedef ptr_type pointer_type; \
\
iterator(Node* node, Node* init) : m_node(node), m_init(init) {}\
iterator() : m_node(NULL), m_init(NULL) { } \
reference_type operator*() const \
{ return *(pointer_type)m_node->GetDataPtr(); } \
- pointer_type operator->() const \
- { return (pointer_type)m_node->GetDataPtr(); } \
+ ptrop \
itor& operator++() { m_node = m_node->GetNext(); return *this; }\
itor operator++(int) \
{ itor tmp = *this; m_node = m_node->GetNext(); return tmp; }\
{ \
typedef name list; \
public: \
- typedef list::Node Node; \
+ typedef nodetype Node; \
+ typedef T* value_type; \
+ typedef const value_type& const_reference; \
typedef const_iterator itor; \
- typedef list::value_type* ptr_type; \
+ typedef value_type* ptr_type; \
\
Node* m_node; \
Node* m_init; \
public: \
- typedef list::const_reference reference_type; \
+ typedef const_reference reference_type; \
typedef const ptr_type pointer_type; \
\
const_iterator(Node* node, Node* init) \
: m_node(it.m_node), m_init(it.m_init) { } \
reference_type operator*() const \
{ return *(pointer_type)m_node->GetDataPtr(); } \
- pointer_type operator->() const \
- { return (pointer_type)m_node->GetDataPtr(); } \
+ ptrop \
itor& operator++() { m_node = m_node->GetNext(); return *this; }\
itor operator++(int) \
{ itor tmp = *this; m_node = m_node->GetNext(); return tmp; }\
{ \
typedef name list; \
public: \
- typedef list::Node Node; \
+ typedef nodetype Node; \
+ typedef T* value_type; \
typedef reverse_iterator itor; \
- typedef list::value_type* ptr_type; \
+ typedef value_type* ptr_type; \
+ typedef value_type& reference; \
\
Node* m_node; \
Node* m_init; \
public: \
- typedef list::reference reference_type; \
+ typedef reference reference_type; \
typedef ptr_type pointer_type; \
\
reverse_iterator(Node* node, Node* init) \
reverse_iterator() : m_node(NULL), m_init(NULL) { } \
reference_type operator*() const \
{ return *(pointer_type)m_node->GetDataPtr(); } \
- pointer_type operator->() const \
- { return (pointer_type)m_node->GetDataPtr(); } \
+ ptrop \
itor& operator++() \
{ m_node = m_node->GetPrevious(); return *this; } \
itor operator++(int) \
{ \
typedef name list; \
public: \
- typedef list::Node Node; \
+ typedef nodetype Node; \
+ typedef T* value_type; \
typedef const_reverse_iterator itor; \
- typedef list::value_type* ptr_type; \
+ typedef value_type* ptr_type; \
+ typedef const value_type& const_reference; \
\
Node* m_node; \
Node* m_init; \
public: \
- typedef list::const_reference reference_type; \
+ typedef const_reference reference_type; \
typedef const ptr_type pointer_type; \
\
const_reverse_iterator(Node* node, Node* init) \
: m_node(it.m_node), m_init(it.m_init) { } \
reference_type operator*() const \
{ return *(pointer_type)m_node->GetDataPtr(); } \
- pointer_type operator->() const \
- { return (pointer_type)m_node->GetDataPtr(); } \
+ ptrop \
itor& operator++() \
{ m_node = m_node->GetPrevious(); return *this; } \
itor operator++(int) \
{ return const_reverse_iterator(NULL, GetFirst()); } \
void resize(size_type n, value_type v = value_type()) \
{ \
- if(n < size()) \
- for(; n < size(); pop_back()); \
- else if(n > size()) \
- for(; n > size(); push_back(v)); \
+ while (n < size()) \
+ pop_back(); \
+ while (n > size()) \
+ push_back(v); \
} \
size_type size() const { return GetCount(); } \
size_type max_size() const { return INT_MAX; } \
} */ \
}
+#define WX_LIST_PTROP \
+ pointer_type operator->() const \
+ { return (pointer_type)m_node->GetDataPtr(); }
+#define WX_LIST_PTROP_NONE
+
+#define WX_DECLARE_LIST_3(T, Tbase, name, nodetype, classexp) \
+ WX_DECLARE_LIST_4(T, Tbase, name, nodetype, classexp, WX_LIST_PTROP_NONE)
+#define WX_DECLARE_LIST_PTR_3(T, Tbase, name, nodetype, classexp) \
+ WX_DECLARE_LIST_4(T, Tbase, name, nodetype, classexp, WX_LIST_PTROP)
+
#define WX_DECLARE_LIST_2(elementtype, listname, nodename, classexp) \
WX_DECLARE_LIST_3(elementtype, elementtype, listname, nodename, classexp)
+#define WX_DECLARE_LIST_PTR_2(elementtype, listname, nodename, classexp) \
+ WX_DECLARE_LIST_PTR_3(elementtype, elementtype, listname, nodename, classexp)
#define WX_DECLARE_LIST(elementtype, listname) \
typedef elementtype _WX_LIST_ITEM_TYPE_##listname; \
WX_DECLARE_LIST_2(elementtype, listname, wx##listname##Node, class)
+#define WX_DECLARE_LIST_PTR(elementtype, listname) \
+ typedef elementtype _WX_LIST_ITEM_TYPE_##listname; \
+ WX_DECLARE_LIST_PTR_2(elementtype, listname, wx##listname##Node, class)
+
+#define WX_DECLARE_LIST_WITH_DECL(elementtype, listname, decl) \
+ typedef elementtype _WX_LIST_ITEM_TYPE_##listname; \
+ WX_DECLARE_LIST_2(elementtype, listname, wx##listname##Node, decl)
#define WX_DECLARE_EXPORTED_LIST(elementtype, listname) \
+ WX_DECLARE_LIST_WITH_DECL(elementtype, listname, class WXDLLEXPORT)
+
+#define WX_DECLARE_EXPORTED_LIST_PTR(elementtype, listname) \
typedef elementtype _WX_LIST_ITEM_TYPE_##listname; \
- WX_DECLARE_LIST_2(elementtype, listname, wx##listname##Node, class WXDLLEXPORT)
+ WX_DECLARE_LIST_PTR_2(elementtype, listname, wx##listname##Node, class WXDLLEXPORT)
#define WX_DECLARE_USER_EXPORTED_LIST(elementtype, listname, usergoo) \
typedef elementtype _WX_LIST_ITEM_TYPE_##listname; \
WX_DECLARE_LIST_2(elementtype, listname, wx##listname##Node, class usergoo)
+#define WX_DECLARE_USER_EXPORTED_LIST_PTR(elementtype, listname, usergoo) \
+ typedef elementtype _WX_LIST_ITEM_TYPE_##listname; \
+ WX_DECLARE_LIST_PTR_2(elementtype, listname, wx##listname##Node, class usergoo)
// this macro must be inserted in your program after
// #include <wx/listimpl.cpp>
#endif // !wxUSE_STL
-// =============================================================================
+// ============================================================================
// now we can define classes 100% compatible with the old ones
-// =============================================================================
+// ============================================================================
// ----------------------------------------------------------------------------
// commonly used list classes
// ----------------------------------------------------------------------------
-#ifdef wxLIST_COMPATIBILITY
+#if defined(wxLIST_COMPATIBILITY)
+
+// inline compatibility functions
+
+#if !wxUSE_STL
+
+// ----------------------------------------------------------------------------
+// wxNodeBase deprecated methods
+// ----------------------------------------------------------------------------
+
+inline wxNode *wxNodeBase::Next() const { return (wxNode *)GetNext(); }
+inline wxNode *wxNodeBase::Previous() const { return (wxNode *)GetPrevious(); }
+inline wxObject *wxNodeBase::Data() const { return (wxObject *)GetData(); }
+
+// ----------------------------------------------------------------------------
+// wxListBase deprecated methods
+// ----------------------------------------------------------------------------
+
+inline int wxListBase::Number() const { return (int)GetCount(); }
+inline wxNode *wxListBase::First() const { return (wxNode *)GetFirst(); }
+inline wxNode *wxListBase::Last() const { return (wxNode *)GetLast(); }
+inline wxNode *wxListBase::Nth(size_t n) const { return (wxNode *)Item(n); }
+inline wxListBase::operator wxList&() const { return *(wxList*)this; }
+
+#endif
// define this to make a lot of noise about use of the old wxList classes.
//#define wxWARN_COMPAT_LIST_USE
-// -----------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
// wxList compatibility class: in fact, it's a list of wxObjects
-// -----------------------------------------------------------------------------
-WX_DECLARE_LIST_2(wxObject, wxObjectList, wxObjectListNode, class WXDLLIMPEXP_BASE);
+// ----------------------------------------------------------------------------
+
+WX_DECLARE_LIST_2(wxObject, wxObjectList, wxObjectListNode,
+ class WXDLLIMPEXP_BASE);
class WXDLLIMPEXP_BASE wxList : public wxObjectList
{
public:
#if defined(wxWARN_COMPAT_LIST_USE) && !wxUSE_STL
- wxDEPRECATED( wxList(int key_type = wxKEY_NONE) );
+ wxList() { };
+ wxDEPRECATED( wxList(int key_type) );
#elif !wxUSE_STL
wxList(int key_type = wxKEY_NONE);
#endif
// ctors and such
// default
#ifdef wxWARN_COMPAT_LIST_USE
- wxDEPRECATED( wxStringList() );
+ wxStringList();
wxDEPRECATED( wxStringList(const wxChar *first ...) );
#else
wxStringList();
// copying the string list: the strings are copied, too (extremely
// inefficient!)
- wxStringList(const wxStringList& other) : wxStringListBase() { DeleteContents(TRUE); DoCopy(other); }
+ wxStringList(const wxStringList& other) : wxStringListBase() { DeleteContents(true); DoCopy(other); }
wxStringList& operator=(const wxStringList& other)
{ Clear(); DoCopy(other); return *this; }
// operations
// makes a copy of the string
wxNode *Add(const wxChar *s);
-
+
// Append to beginning of list
wxNode *Prepend(const wxChar *s);
bool Delete(const wxChar *s);
- wxChar **ListToArray(bool new_copies = FALSE) const;
+ wxChar **ListToArray(bool new_copies = false) const;
bool Member(const wxChar *s) const;
// alphabetic sort
class WXDLLEXPORT wxStringList : public wxStringListBase
{
public:
+ compatibility_iterator Append(wxChar* s)
+ { wxString tmp = s; delete[] s; return wxStringListBase::Append(tmp); }
+ compatibility_iterator Insert(wxChar* s)
+ { wxString tmp = s; delete[] s; return wxStringListBase::Insert(tmp); }
+ compatibility_iterator Insert(size_t pos, wxChar* s)
+ {
+ wxString tmp = s;
+ delete[] s;
+ return wxStringListBase::Insert(pos, tmp);
+ }
+ compatibility_iterator Add(const wxChar* s)
+ { push_back(s); return GetLast(); }
+ compatibility_iterator Prepend(const wxChar* s)
+ { push_front(s); return GetFirst(); }
};
#endif // wxUSE_STL
projects / wxWidgets.git / blobdiff