like the old class.
*/
-#ifndef _WX_LISTH__
-#define _WX_LISTH__
+#ifndef _WX_LIST_H_
+#define _WX_LIST_H_
// -----------------------------------------------------------------------------
// headers
// types
// ----------------------------------------------------------------------------
-// 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);
-}
-
-class WXDLLIMPEXP_BASE wxObjectListNode;
+class WXDLLIMPEXP_FWD_BASE wxObjectListNode;
typedef wxObjectListNode wxNode;
-//
-typedef int (* LINKAGEMODE wxListIterateFunction)(void *current);
-
#if wxUSE_STL
#define wxLIST_COMPATIBILITY
#if !defined(__VISUALC__) || __VISUALC__ >= 1300 // == !VC6
template<class T>
-class WXDLLIMPEXP_BASE wxList_SortFunction
+class wxList_SortFunction
{
public:
wxList_SortFunction(wxSortCompareFunction f) : m_f(f) { }
};
#define WX_LIST_SORTFUNCTION( elT, f ) wxList_SortFunction<elT>(f)
-#define VC6_WORKAROUND(elT, liT, decl)
+#define WX_LIST_VC6_WORKAROUND(elT, liT, decl)
#else // if defined( __VISUALC__ ) && __VISUALC__ < 1300 // == VC6
#define WX_LIST_SORTFUNCTION( elT, f ) std::greater<elT>( f )
-#define VC6_WORKAROUND(elT, liT, decl) \
+#define WX_LIST_VC6_WORKAROUND(elT, liT, decl) \
decl liT; \
\
/* Workaround for broken VC6 STL incorrectly requires a std::greater<> */ \
for mingw 3.2.3 compiler bug that prevents a static function of liT class
from being exported into dll. A minimal code snippet reproducing the bug:
- struct WXDLLEXPORT Foo
+ struct WXDLLIMPEXP_CORE Foo
{
static void Bar();
struct SomeInnerClass
static void DeleteFunction( _WX_LIST_ITEM_TYPE_##liT X ); \
}; \
\
- VC6_WORKAROUND(elT, liT, decl) \
+ WX_LIST_VC6_WORKAROUND(elT, liT, decl) \
decl liT : public std::list<elT> \
{ \
private: \
bool operator==(const compatibility_iterator& i) const \
{ \
wxASSERT_MSG( m_list && i.m_list, \
- _T("comparing invalid iterators is illegal") ); \
+ wxT("comparing invalid iterators is illegal") ); \
return (m_list == i.m_list) && (m_iter == i.m_iter); \
} \
bool operator!=(const compatibility_iterator& i) const \
iterator i = const_cast< liT* >(this)->end(); \
return compatibility_iterator( this, !empty() ? --i : i ); \
} \
- compatibility_iterator Member( elT e ) const \
+ bool Member( elT e ) const \
{ return Find( e ); } \
compatibility_iterator Nth( int n ) const \
{ return Item( n ); } \
push_front( e ); \
return compatibility_iterator( this, begin() ); \
} \
- compatibility_iterator Insert( compatibility_iterator & i, elT e ) \
+ compatibility_iterator Insert(const compatibility_iterator & i, elT e)\
{ \
return compatibility_iterator( this, insert( i.m_iter, e ) ); \
} \
~liT() { Clear(); } \
\
/* It needs access to our EmptyList */ \
- friend decl compatibility_iterator; \
+ friend class compatibility_iterator; \
}
#define WX_DECLARE_LIST(elementtype, listname) \
WX_DECLARE_LIST(elementtype, listname)
#define WX_DECLARE_EXPORTED_LIST(elementtype, listname) \
- WX_DECLARE_LIST_WITH_DECL(elementtype, listname, class WXDLLEXPORT)
+ WX_DECLARE_LIST_WITH_DECL(elementtype, listname, class WXDLLIMPEXP_CORE)
#define WX_DECLARE_EXPORTED_LIST_PTR(elementtype, listname) \
WX_DECLARE_EXPORTED_LIST(elementtype, listname)
{ m_key.integer = i; }
wxListKey(const wxString& s) : m_keyType(wxKEY_STRING)
{ m_key.string = new wxString(s); }
+ wxListKey(const char *s) : m_keyType(wxKEY_STRING)
+ { m_key.string = new wxString(s); }
+ wxListKey(const wchar_t *s) : m_keyType(wxKEY_STRING)
+ { m_key.string = new wxString(s); }
// accessors
wxKeyType GetKeyType() const { return m_keyType; }
extern WXDLLIMPEXP_DATA_BASE(wxListKey) wxDefaultListKey;
-class WXDLLIMPEXP_BASE wxListBase;
+class WXDLLIMPEXP_FWD_BASE wxListBase;
class WXDLLIMPEXP_BASE wxNodeBase
{
friend class wxListBase;
public:
// ctor
- wxNodeBase(wxListBase *list = (wxListBase *)NULL,
- wxNodeBase *previous = (wxNodeBase *)NULL,
- wxNodeBase *next = (wxNodeBase *)NULL,
+ wxNodeBase(wxListBase *list = NULL,
+ wxNodeBase *previous = NULL,
+ wxNodeBase *next = NULL,
void *data = NULL,
const wxListKey& key = wxDefaultListKey);
virtual void DeleteData() { }
public:
// for wxList::iterator
- void** GetDataPtr() const { return &(((wxNodeBase*)this)->m_data); }
+ void** GetDataPtr() const { return &(const_cast<wxNodeBase*>(this)->m_data); }
private:
// optional key stuff
wxListKeyValue m_key;
wxListBase *m_list; // list we belong to
- DECLARE_NO_COPY_CLASS(wxNodeBase)
+ wxDECLARE_NO_COPY_CLASS(wxNodeBase);
};
// -----------------------------------------------------------------------------
// a double-linked list class
// -----------------------------------------------------------------------------
-class WXDLLIMPEXP_BASE wxList;
+class WXDLLIMPEXP_FWD_BASE wxList;
-class WXDLLIMPEXP_BASE wxListBase : public wxObject
+class WXDLLIMPEXP_BASE wxListBase
{
-friend class WXDLLIMPEXP_BASE wxNodeBase; // should be able to call DetachNode()
+friend class wxNodeBase; // should be able to call DetachNode()
friend class wxHashTableBase; // should be able to call untyped Find()
public:
void *data,
const wxListKey& key = wxDefaultListKey) = 0;
-// Can't access these from derived classes otherwise (bug in Salford C++?)
-#ifdef __SALFORDC__
-public:
-#endif
// ctors
// from an array
{
wxNodeBase *node = Item(n);
- return node ? node->GetData() : (wxNodeBase *)NULL;
+ return node ? node->GetData() : NULL;
}
// operations
// append to beginning of list
wxNodeBase *Append(void *object);
// insert a new item at the beginning of the list
- wxNodeBase *Insert(void *object) { return Insert( (wxNodeBase*)NULL, object); }
+ wxNodeBase *Insert(void *object)
+ { return Insert(static_cast<wxNodeBase *>(NULL), object); }
// insert a new item at the given position
wxNodeBase *Insert(size_t pos, void *object)
{ return pos == GetCount() ? Append(object)
classexp nodetype : public wxNodeBase \
{ \
public: \
- nodetype(wxListBase *list = (wxListBase *)NULL, \
- nodetype *previous = (nodetype *)NULL, \
- nodetype *next = (nodetype *)NULL, \
- T *data = (T *)NULL, \
+ nodetype(wxListBase *list = NULL, \
+ nodetype *previous = NULL, \
+ nodetype *next = NULL, \
+ T *data = NULL, \
const wxListKey& key = wxDefaultListKey) \
: wxNodeBase(list, previous, next, data, key) { } \
\
: wxListBase(count, (void **)elements) { } \
\
name& operator=(const name& list) \
- { Assign(list); return *this; } \
+ { if (&list != this) Assign(list); return *this; } \
\
nodetype *GetFirst() const \
{ return (nodetype *)wxListBase::GetFirst(); } \
T *operator[](size_t index) const \
{ \
nodetype *node = Item(index); \
- return node ? (T*)(node->GetData()) : (T*)NULL; \
+ return node ? (T*)(node->GetData()) : NULL; \
} \
\
nodetype *Append(Tbase *object) \
{ return (nodetype *)wxListBase::Append(object); } \
nodetype *Insert(Tbase *object) \
- { return (nodetype *)Insert((nodetype*)NULL, object); } \
+ { return (nodetype *)Insert(static_cast<nodetype *>(NULL), \
+ object); } \
nodetype *Insert(size_t pos, Tbase *object) \
{ return (nodetype *)wxListBase::Insert(pos, object); } \
nodetype *Insert(nodetype *prev, Tbase *object) \
for(size_type i = 0; i < n; ++i) \
Append((const_base_reference)v); \
} \
- iterator insert(const iterator& it, const_reference v = value_type())\
+ iterator insert(const iterator& it, const_reference v) \
{ \
- Insert(it.m_node, (const_base_reference)v); \
- return iterator(it.m_node->GetPrevious(), GetLast()); \
+ if ( it == end() ) \
+ Append((const_base_reference)v); \
+ else \
+ Insert(it.m_node, (const_base_reference)v); \
+ iterator itprev(it); \
+ return itprev--; \
} \
- void insert(const iterator& it, size_type n, const_reference v = value_type())\
+ void insert(const iterator& it, size_type n, const_reference v) \
{ \
for(size_type i = 0; i < n; ++i) \
- Insert(it.m_node, (const_base_reference)v); \
+ insert(it, v); \
} \
- void insert(const iterator& it, const_iterator first, const const_iterator& last)\
+ void insert(const iterator& it, \
+ const_iterator first, const const_iterator& last) \
{ \
for(; first != last; ++first) \
- Insert(it.m_node, (const_base_reference)*first); \
+ insert(it, *first); \
} \
iterator erase(const iterator& it) \
{ \
} \
iterator erase(const iterator& first, const iterator& last) \
{ \
- iterator next = last; ++next; \
+ iterator next = last; \
+ if ( next != end() ) \
+ ++next; \
DeleteNodes(first.m_node, last.m_node); \
return next; \
} \
{ splice(it, l, l.begin(), l.end() ); } \
void splice(const iterator& it, name& l, const iterator& first) \
{ \
- iterator tmp = first; ++tmp; \
- if(it == first || it == tmp) return; \
- insert(it, *first); \
- l.erase(first); \
+ if ( it != first ) \
+ { \
+ insert(it, *first); \
+ l.erase(first); \
+ } \
} \
void remove(const_reference v) \
{ DeleteObject((const_base_reference)v); } \
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)
+ WX_DECLARE_LIST_WITH_DECL(elementtype, listname, class WXDLLIMPEXP_CORE)
#define WX_DECLARE_EXPORTED_LIST_PTR(elementtype, listname) \
typedef elementtype _WX_LIST_ITEM_TYPE_##listname; \
- WX_DECLARE_LIST_PTR_2(elementtype, listname, wx##listname##Node, class WXDLLEXPORT)
+ WX_DECLARE_LIST_PTR_2(elementtype, listname, wx##listname##Node, class WXDLLIMPEXP_CORE)
#define WX_DECLARE_USER_EXPORTED_LIST(elementtype, listname, usergoo) \
typedef elementtype _WX_LIST_ITEM_TYPE_##listname; \
#if !wxUSE_STL
wxList& operator=(const wxList& list)
- { (void) wxListBase::operator=(list); return *this; }
+ { if (&list != this) Assign(list); return *this; }
// compatibility methods
void Sort(wxSortCompareFunction compfunc) { wxListBase::Sort(compfunc); }
-#endif
-
-#if wxUSE_STL
-#else
- wxNode *Member(wxObject *object) const { return (wxNode *)Find(object); }
-#endif
-
-private:
-#if !wxUSE_STL
- DECLARE_DYNAMIC_CLASS(wxList)
-#endif
+ bool Member(wxObject *object) const { return Find(object) != NULL; }
+#endif // !wxUSE_STL
};
#if !wxUSE_STL
// inefficient!)
wxStringList(const wxStringList& other) : wxStringListBase() { DeleteContents(true); DoCopy(other); }
wxStringList& operator=(const wxStringList& other)
- { Clear(); DoCopy(other); return *this; }
+ {
+ if (&other != this)
+ {
+ Clear();
+ DoCopy(other);
+ }
+ return *this;
+ }
// operations
// makes a copy of the string
private:
void DoCopy(const wxStringList&); // common part of copy ctor and operator=
-
- DECLARE_DYNAMIC_CLASS(wxStringList)
};
#else // if wxUSE_STL
(list).clear(); \
}
+// append all element of one list to another one
+#define WX_APPEND_LIST(list, other) \
+ { \
+ wxList::compatibility_iterator node = other->GetFirst(); \
+ while ( node ) \
+ { \
+ (list)->push_back(node->GetData()); \
+ node = node->GetNext(); \
+ } \
+ }
+
#endif // _WX_LISTH__
projects / wxWidgets.git / blobdiff