///////////////////////////////////////////////////////////////////////////////
-// Name: dlist.h
+// Name: wx/dlist.h
// Purpose: wxDList<T> which is a template version of wxList
// Author: Robert Roebling
// Created: 18.09.2008
#include "wx/defs.h"
#include "wx/utils.h"
-#if wxUSE_STL
+#if wxUSE_STD_CONTAINERS
#include "wx/beforestd.h"
#include <algorithm>
bool m_destroy;
typedef std::list<T*> BaseListType;
typedef wxDList<T> ListType;
-
+
public:
+ typedef typename BaseListType::iterator iterator;
+
+ class compatibility_iterator
+ {
+ private:
+ /* Workaround for broken VC6 nested class name resolution */
typedef typename BaseListType::iterator iterator;
-
- class compatibility_iterator
+ friend class wxDList<T>;
+
+ iterator m_iter;
+ ListType *m_list;
+
+ public:
+ compatibility_iterator()
+ : m_iter(), m_list( NULL ) {}
+ compatibility_iterator( ListType* li, iterator i )
+ : m_iter( i ), m_list( li ) {}
+ compatibility_iterator( const ListType* li, iterator i )
+ : m_iter( i ), m_list( const_cast<ListType*>(li) ) {}
+
+ compatibility_iterator* operator->() { return this; }
+ const compatibility_iterator* operator->() const { return this; }
+
+ bool operator==(const compatibility_iterator& i) const
{
- private:
- /* Workaround for broken VC6 nested class name resolution */
- typedef typename BaseListType::iterator iterator;
- friend class wxDList<T>;
-
- iterator m_iter;
- ListType *m_list;
-
- public:
- compatibility_iterator()
- : m_iter(), m_list( NULL ) {}
- compatibility_iterator( ListType* li, iterator i )
- : m_iter( i ), m_list( li ) {}
- compatibility_iterator( const ListType* li, iterator i )
- : m_iter( i ), m_list( const_cast<ListType*>(li) ) {}
-
- compatibility_iterator* operator->() { return this; }
- const compatibility_iterator* operator->() const { return this; }
-
- bool operator==(const compatibility_iterator& i) const
- {
- wxASSERT_MSG( m_list && i.m_list,
- wxT("comparing invalid iterators is illegal") );
- return (m_list == i.m_list) && (m_iter == i.m_iter);
- }
- bool operator!=(const compatibility_iterator& i) const
- { return !( operator==( i ) ); }
- operator bool() const
- { return m_list ? m_iter != m_list->end() : false; }
- bool operator !() const
- { return !( operator bool() ); }
-
- T* GetData() const
- { return *m_iter; }
- void SetData( T* e )
- { *m_iter = e; }
-
- compatibility_iterator GetNext() const
- {
- iterator i = m_iter;
- return compatibility_iterator( m_list, ++i );
- }
- compatibility_iterator GetPrevious() const
- {
- if ( m_iter == m_list->begin() )
- return compatibility_iterator();
-
- iterator i = m_iter;
- return compatibility_iterator( m_list, --i );
- }
- int IndexOf() const
- {
- return *this ? std::distance( m_list->begin(), m_iter )
- : wxNOT_FOUND;
- }
- };
- public:
- wxDList() : m_destroy( false ) {}
-
- ~wxDList() { Clear(); }
-
- compatibility_iterator Find( const T* e ) const
- {
- return compatibility_iterator( this,
- std::find( const_cast<ListType*>(this)->begin(), const_cast<ListType*>(this)->end(), e ) );
- }
-
- bool IsEmpty() const
- { return this->empty(); }
- size_t GetCount() const
- { return this->size(); }
-
- compatibility_iterator Item( size_t idx ) const
- {
- iterator i = const_cast<ListType*>(this)->begin();
- std::advance( i, idx );
- return compatibility_iterator( this, i );
- }
- T* operator[](size_t idx) const
- {
- return Item(idx).GetData();
- }
-
- compatibility_iterator GetFirst() const
- {
- return compatibility_iterator( this, const_cast<ListType*>(this)->begin() );
- }
- compatibility_iterator GetLast() const
- {
- iterator i = const_cast<ListType*>(this)->end();
- return compatibility_iterator( this, !(this->empty()) ? --i : i );
- }
- compatibility_iterator Member( T* e ) const
- { return Find( e ); }
- compatibility_iterator Nth( int n ) const
- { return Item( n ); }
- int IndexOf( T* e ) const
- { return Find( e ).IndexOf(); }
-
- compatibility_iterator Append( T* e )
- {
- this->push_back( e );
- return GetLast();
- }
- compatibility_iterator Insert( T* e )
- {
- this->push_front( e );
- return compatibility_iterator( this, this->begin() );
- }
- compatibility_iterator Insert( compatibility_iterator & i, T* e )
- {
- return compatibility_iterator( this, this->insert( i.m_iter, e ) );
- }
- compatibility_iterator Insert( size_t idx, T* e )
- {
- return compatibility_iterator( this,
- this->insert( Item( idx ).m_iter, e ) );
- }
-
- void DeleteContents( bool destroy )
- { m_destroy = destroy; }
- bool GetDeleteContents() const
- { return m_destroy; }
- void Erase( const compatibility_iterator& i )
- {
- if ( m_destroy )
- delete i->GetData();
- this->erase( i.m_iter );
- }
- bool DeleteNode( const compatibility_iterator& i )
- {
- if( i )
- {
- Erase( i );
- return true;
- }
- return false;
- }
- bool DeleteObject( T* e )
- {
- return DeleteNode( Find( e ) );
- }
- void Clear()
- {
- if ( m_destroy )
- {
- iterator it, en;
- for ( it = this->begin(), en = this->end(); it != en; ++it )
- delete *it;
- }
- this->clear();
- }
+ wxASSERT_MSG( m_list && i.m_list,
+ "comparing invalid iterators is illegal" );
+ return (m_list == i.m_list) && (m_iter == i.m_iter);
+ }
+ bool operator!=(const compatibility_iterator& i) const
+ { return !( operator==( i ) ); }
+ operator bool() const
+ { return m_list ? m_iter != m_list->end() : false; }
+ bool operator !() const
+ { return !( operator bool() ); }
+
+ T* GetData() const { return *m_iter; }
+ void SetData( T* e ) { *m_iter = e; }
+
+ compatibility_iterator GetNext() const
+ {
+ iterator i = m_iter;
+ return compatibility_iterator( m_list, ++i );
+ }
+
+ compatibility_iterator GetPrevious() const
+ {
+ if ( m_iter == m_list->begin() )
+ return compatibility_iterator();
+
+ iterator i = m_iter;
+ return compatibility_iterator( m_list, --i );
+ }
+
+ int IndexOf() const
+ {
+ return *this ? std::distance( m_list->begin(), m_iter )
+ : wxNOT_FOUND;
+ }
+ };
+
+public:
+ wxDList() : m_destroy( false ) {}
+
+ ~wxDList() { Clear(); }
+
+ compatibility_iterator Find( const T* e ) const
+ {
+ return compatibility_iterator( this,
+ std::find( const_cast<ListType*>(this)->begin(),
+ const_cast<ListType*>(this)->end(), e ) );
+ }
+
+ bool IsEmpty() const
+ { return this->empty(); }
+ size_t GetCount() const
+ { return this->size(); }
+
+ compatibility_iterator Item( size_t idx ) const
+ {
+ iterator i = const_cast<ListType*>(this)->begin();
+ std::advance( i, idx );
+ return compatibility_iterator( this, i );
+ }
+
+ T* operator[](size_t idx) const
+ {
+ return Item(idx).GetData();
+ }
+
+ compatibility_iterator GetFirst() const
+ {
+ return compatibility_iterator( this, const_cast<ListType*>(this)->begin() );
+ }
+ compatibility_iterator GetLast() const
+ {
+ iterator i = const_cast<ListType*>(this)->end();
+ return compatibility_iterator( this, !(this->empty()) ? --i : i );
+ }
+ compatibility_iterator Member( T* e ) const
+ { return Find( e ); }
+ compatibility_iterator Nth( int n ) const
+ { return Item( n ); }
+ int IndexOf( T* e ) const
+ { return Find( e ).IndexOf(); }
+
+ compatibility_iterator Append( T* e )
+ {
+ this->push_back( e );
+ return GetLast();
+ }
+
+ compatibility_iterator Insert( T* e )
+ {
+ this->push_front( e );
+ return compatibility_iterator( this, this->begin() );
+ }
+
+ compatibility_iterator Insert( compatibility_iterator & i, T* e )
+ {
+ return compatibility_iterator( this, this->insert( i.m_iter, e ) );
+ }
+
+ compatibility_iterator Insert( size_t idx, T* e )
+ {
+ return compatibility_iterator( this,
+ this->insert( Item( idx ).m_iter, e ) );
+ }
+
+ void DeleteContents( bool destroy )
+ { m_destroy = destroy; }
+
+ bool GetDeleteContents() const
+ { return m_destroy; }
+
+ void Erase( const compatibility_iterator& i )
+ {
+ if ( m_destroy )
+ delete i->GetData();
+ this->erase( i.m_iter );
+ }
+
+ bool DeleteNode( const compatibility_iterator& i )
+ {
+ if( i )
+ {
+ Erase( i );
+ return true;
+ }
+ return false;
+ }
+
+ bool DeleteObject( T* e )
+ {
+ return DeleteNode( Find( e ) );
+ }
+
+ void Clear()
+ {
+ if ( m_destroy )
+ {
+ iterator it, en;
+ for ( it = this->begin(), en = this->end(); it != en; ++it )
+ delete *it;
+ }
+ this->clear();
+ }
};
-#else // STL
-
-template<typename T>
+#else // !wxUSE_STD_CONTAINERS
+
+template <typename T>
class wxDList
{
-public:
+public:
class Node
{
- friend class wxDList<T>;
public:
- Node( wxDList<T> *list = NULL, Node *previous = NULL, Node *next = NULL, T *data = NULL )
+ Node(wxDList<T> *list = NULL,
+ Node *previous = NULL,
+ Node *next = NULL,
+ T *data = NULL)
{
m_list = list;
m_previous = previous;
~Node()
{
// handle the case when we're being deleted from the list by
- // the user (i.e. not by the list itself from DeleteNode) -
+ // the user (i.e. not by the list itself from DeleteNode) -
// we must do it for compatibility with old code
if (m_list != NULL)
m_list->DetachNode(this);
}
-
+
void DeleteData()
{
delete m_data;
}
-
+
Node *GetNext() const { return m_next; }
Node *GetPrevious() const { return m_previous; }
T *GetData() const { return m_data; }
T **GetDataPtr() const { return &(wx_const_cast(nodetype*,this)->m_data); }
void SetData( T *data ) { m_data = data; }
-
+
int IndexOf() const
{
- wxCHECK_MSG( m_list, wxNOT_FOUND, wxT("node doesn't belong to a list in IndexOf"));
-
+ wxCHECK_MSG( m_list, wxNOT_FOUND,
+ "node doesn't belong to a list in IndexOf" );
+
int i;
Node *prev = m_previous;
for( i = 0; prev; i++ )
prev = prev->m_previous;
return i;
}
-
+
private:
T *m_data; // user data
Node *m_next, // next and previous nodes in the list
*m_previous;
wxDList<T> *m_list; // list we belong to
+
+ friend class wxDList<T>;
};
-
+
typedef Node nodetype;
-
+
class compatibility_iterator
{
public:
compatibility_iterator(nodetype *ptr = NULL) : m_ptr(ptr) { }
nodetype *operator->() const { return m_ptr; }
operator nodetype *() const { return m_ptr; }
+
private:
nodetype *m_ptr;
- };
-
-
+ };
+
private:
void Init()
{
m_count = 0;
m_destroy = false;
}
-
+
void DoDeleteNode( nodetype *node )
{
if ( m_destroy )
bool m_destroy; // destroy user data when deleting list items?
nodetype *m_nodeFirst, // pointers to the head and tail of the list
*m_nodeLast;
-
-
-public:
+
+public:
wxDList()
{
Init();
}
-
+
wxDList( const wxDList<T>& list )
- {
+ {
Init();
- Assign(list);
+ Assign(list);
}
-
+
wxDList( size_t count, T *elements[] )
{
Init();
for (n = 0; n < count; n++)
Append( elements[n] );
}
-
+
wxDList& operator=( const wxDList<T>& list )
- {
- if (&list != this)
- Assign(list);
+ {
+ if (&list != this)
+ Assign(list);
return *this;
}
-
+
~wxDList()
{
nodetype *each = m_nodeFirst;
each = next;
}
}
-
+
void Assign(const wxDList<T> &list)
{
wxASSERT_MSG( !list.m_destroy,
- wxT("copying list which owns it's elements is a bad idea") );
+ "copying list which owns it's elements is a bad idea" );
Clear();
m_destroy = list.m_destroy;
m_nodeFirst = NULL;
nodetype* node;
for (node = list.GetFirst(); node; node = node->GetNext() )
Append(node->GetData());
- wxASSERT_MSG( m_count == list.m_count, wxT("logic error in Assign()") );
+ wxASSERT_MSG( m_count == list.m_count, "logic error in Assign()" );
}
-
+
nodetype *Append( T *object )
{
nodetype *node = new nodetype( this, m_nodeLast, NULL, object );
-
+
if ( !m_nodeFirst )
{
m_nodeFirst = node;
m_count++;
return node;
}
-
+
nodetype *Insert( T* object )
- {
+ {
return Insert( NULL, object );
}
+
nodetype *Insert( size_t pos, T* object )
{
if (pos == m_count)
else
return Insert( Item(pos), object );
}
+
nodetype *Insert( nodetype *position, T* object )
{
wxCHECK_MSG( !position || position->m_list == this, NULL,
- wxT("can't insert before a node from another list") );
-
+ "can't insert before a node from another list" );
+
// previous and next node for the node being inserted
nodetype *prev, *next;
if ( position )
m_count++;
return node;
}
-
-
- nodetype *GetFirst() const
- {
- return m_nodeFirst;
- }
- nodetype *GetLast() const
- {
- return m_nodeLast;
- }
- size_t GetCount() const
- {
- return m_count;
- }
- bool IsEmpty() const
- {
- return m_count == 0;
- }
-
- void DeleteContents(bool destroy)
- {
- m_destroy = destroy;
- }
- bool GetDeleteContents() const
- {
- return m_destroy;
- }
-
+
+ nodetype *GetFirst() const { return m_nodeFirst; }
+ nodetype *GetLast() const { return m_nodeLast; }
+ size_t GetCount() const { return m_count; }
+ bool IsEmpty() const { return m_count == 0; }
+
+ void DeleteContents(bool destroy) { m_destroy = destroy; }
+ bool GetDeleteContents() const { return m_destroy; }
+
nodetype *Item(size_t index) const
- {
+ {
for ( nodetype *current = GetFirst(); current; current = current->GetNext() )
{
if ( index-- == 0 )
return current;
}
- wxFAIL_MSG( wxT("invalid index in Item()") );
+ wxFAIL_MSG( "invalid index in Item()" );
return NULL;
}
-
- T *operator[](size_t index) const
- {
- nodetype *node = Item(index);
+
+ T *operator[](size_t index) const
+ {
+ nodetype *node = Item(index);
return node ? node->GetData() : NULL;
}
-
+
nodetype *DetachNode( nodetype *node )
{
- wxCHECK_MSG( node, NULL, wxT("detaching NULL wxNodeBase") );
+ wxCHECK_MSG( node, NULL, "detaching NULL wxNodeBase" );
wxCHECK_MSG( node->m_list == this, NULL,
- wxT("detaching node which is not from this list") );
+ "detaching node which is not from this list" );
// update the list
nodetype **prevNext = node->GetPrevious() ? &node->GetPrevious()->m_next
: &m_nodeFirst;
node->m_list = NULL;
return node;
}
-
+
void Erase( nodetype *node )
- {
+ {
DeleteNode(node);
- }
+ }
+
bool DeleteNode( nodetype *node )
{
if ( !DetachNode(node) )
DoDeleteNode(node);
return true;
}
-
+
bool DeleteObject( T *object )
{
for ( nodetype *current = GetFirst(); current; current = current->GetNext() )
// not found
return false;
}
-
+
nodetype *Find(const T *object) const
{
for ( nodetype *current = GetFirst(); current; current = current->GetNext() )
// not found
return NULL;
}
-
+
int IndexOf(const T *object) const
{
int n = 0;
}
return wxNOT_FOUND;
}
-
+
void Clear()
{
nodetype *current = m_nodeFirst;
// swap first and last node
tmp = m_nodeFirst; m_nodeFirst = m_nodeLast; m_nodeLast = tmp;
}
-
-
-
+
void DeleteNodes(nodetype* first, nodetype* last)
{
nodetype * node = first;
}
return NULL;
}
-
- /* STL interface */
- public:
- typedef size_t size_type;
- typedef int difference_type;
- typedef T* value_type;
- typedef value_type& reference;
- typedef const value_type& const_reference;
-
- class iterator
- {
- public:
- typedef nodetype Node;
- typedef iterator itor;
- typedef T* value_type;
- typedef value_type* ptr_type;
- typedef value_type& reference;
-
- Node* m_node;
- Node* m_init;
- public:
- 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 *m_node->GetDataPtr(); }
- // ptrop
- itor& operator++() { m_node = m_node->GetNext(); return *this; }
- const itor operator++(int)
- { itor tmp = *this; m_node = m_node->GetNext(); return tmp; }
- itor& operator--()
- {
- m_node = m_node ? m_node->GetPrevious() : m_init;
- return *this;
- }
- const itor operator--(int)
- {
- itor tmp = *this;
- m_node = m_node ? m_node->GetPrevious() : m_init;
- return tmp;
- }
- bool operator!=(const itor& it) const
- { return it.m_node != m_node; }
- bool operator==(const itor& it) const
- { return it.m_node == m_node; }
- };
- class const_iterator
- {
- public:
- typedef nodetype Node;
- typedef T* value_type;
- typedef const value_type& const_reference;
- typedef const_iterator itor;
- typedef value_type* ptr_type;
-
- Node* m_node;
- Node* m_init;
- public:
- typedef const_reference reference_type;
- typedef const ptr_type pointer_type;
-
- const_iterator(Node* node, Node* init)
- : m_node(node), m_init(init) { }
- const_iterator() : m_node(NULL), m_init(NULL) { }
- const_iterator(const iterator& it)
- : m_node(it.m_node), m_init(it.m_init) { }
- reference_type operator*() const
- { return *m_node->GetDataPtr(); }
- // ptrop
- itor& operator++() { m_node = m_node->GetNext(); return *this; }
- const itor operator++(int)
- { itor tmp = *this; m_node = m_node->GetNext(); return tmp; }
- itor& operator--()
- {
- m_node = m_node ? m_node->GetPrevious() : m_init;
- return *this;
- }
- const itor operator--(int)
- {
- itor tmp = *this;
- m_node = m_node ? m_node->GetPrevious() : m_init;
- return tmp;
- }
- bool operator!=(const itor& it) const
- { return it.m_node != m_node; }
- bool operator==(const itor& it) const
- { return it.m_node == m_node; }
- };
- class reverse_iterator
- {
- public:
- typedef nodetype Node;
- typedef T* value_type;
- typedef reverse_iterator itor;
- typedef value_type* ptr_type;
- typedef value_type& reference;
-
- Node* m_node;
- Node* m_init;
- public:
- typedef reference reference_type;
- typedef ptr_type pointer_type;
-
- reverse_iterator(Node* node, Node* init)
- : m_node(node), m_init(init) { }
- reverse_iterator() : m_node(NULL), m_init(NULL) { }
- reference_type operator*() const
- { return *m_node->GetDataPtr(); }
- // ptrop
- itor& operator++()
- { m_node = m_node->GetPrevious(); return *this; }
- const itor operator++(int)
- { itor tmp = *this; m_node = m_node->GetPrevious(); return tmp; }
- itor& operator--()
- { m_node = m_node ? m_node->GetNext() : m_init; return *this; }
- const itor operator--(int)
- {
- itor tmp = *this;
- m_node = m_node ? m_node->GetNext() : m_init;
- return tmp;
- }
- bool operator!=(const itor& it) const
- { return it.m_node != m_node; }
- bool operator==(const itor& it) const
- { return it.m_node == m_node; }
- };
- class const_reverse_iterator
- {
- public:
- typedef nodetype Node;
- typedef T* value_type;
- typedef const_reverse_iterator itor;
- typedef value_type* ptr_type;
- typedef const value_type& const_reference;
-
- Node* m_node;
- Node* m_init;
- public:
- typedef const_reference reference_type;
- typedef const ptr_type pointer_type;
-
- const_reverse_iterator(Node* node, Node* init)
- : m_node(node), m_init(init) { }
- const_reverse_iterator() : m_node(NULL), m_init(NULL) { }
- const_reverse_iterator(const reverse_iterator& it)
- : m_node(it.m_node), m_init(it.m_init) { }
- reference_type operator*() const
- { return *m_node->GetDataPtr(); }
- // ptrop
- itor& operator++()
- { m_node = m_node->GetPrevious(); return *this; }
- const itor operator++(int)
- { itor tmp = *this; m_node = m_node->GetPrevious(); return tmp; }
- itor& operator--()
- { m_node = m_node ? m_node->GetNext() : m_init; return *this;}
- const itor operator--(int)
- {
- itor tmp = *this;
- m_node = m_node ? m_node->GetNext() : m_init;
- return tmp;
- }
- bool operator!=(const itor& it) const
- { return it.m_node != m_node; }
- bool operator==(const itor& it) const
- { return it.m_node == m_node; }
- };
-
- wxEXPLICIT wxDList(size_type n, const_reference v = value_type())
- { assign(n, v); }
- wxDList(const const_iterator& first, const const_iterator& last)
- { assign(first, last); }
- iterator begin() { return iterator(GetFirst(), GetLast()); }
- const_iterator begin() const
- { return const_iterator(GetFirst(), GetLast()); }
- iterator end() { return iterator(NULL, GetLast()); }
- const_iterator end() const { return const_iterator(NULL, GetLast()); }
- reverse_iterator rbegin()
- { return reverse_iterator(GetLast(), GetFirst()); }
- const_reverse_iterator rbegin() const
- { return const_reverse_iterator(GetLast(), GetFirst()); }
- reverse_iterator rend() { return reverse_iterator(NULL, GetFirst()); }
- const_reverse_iterator rend() const
- { return const_reverse_iterator(NULL, GetFirst()); }
- void resize(size_type n, value_type v = value_type())
- {
- 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; }
- bool empty() const { return IsEmpty(); }
- reference front() { return *begin(); }
- const_reference front() const { return *begin(); }
- reference back() { iterator tmp = end(); return *--tmp; }
- const_reference back() const { const_iterator tmp = end(); return *--tmp; }
- void push_front(const_reference v = value_type())
- { Insert(GetFirst(), v); }
- void pop_front() { DeleteNode(GetFirst()); }
- void push_back(const_reference v = value_type())
- { Append( v ); }
- void pop_back() { DeleteNode(GetLast()); }
- void assign(const_iterator first, const const_iterator& last)
- {
- clear();
- for(; first != last; ++first)
- Append(*first);
- }
- void assign(size_type n, const_reference v = value_type())
- {
- clear();
- for(size_type i = 0; i < n; ++i)
- Append(v);
- }
- iterator insert(const iterator& it, const_reference v = value_type())
- {
- Insert(it.m_node,v);
- iterator itprev(it);
- return itprev--;
- }
- void insert(const iterator& it, size_type n, const_reference v = value_type())
- {
- for(size_type i = 0; i < n; ++i)
- Insert(it.m_node, v);
- }
- void insert(const iterator& it, const_iterator first, const const_iterator& last)
- {
- for(; first != last; ++first)
- Insert(it.m_node, *first);
- }
- iterator erase(const iterator& it)
- {
- iterator next = iterator(it.m_node->GetNext(), GetLast());
- DeleteNode(it.m_node); return next;
- }
- iterator erase(const iterator& first, const iterator& last)
- {
- iterator next = last; ++next;
- DeleteNodes(first.m_node, last.m_node);
- return next;
- }
- void clear() { Clear(); }
- void splice(const iterator& it, wxDList<T>& l, const iterator& first, const iterator& last)
- { insert(it, first, last); l.erase(first, last); }
- void splice(const iterator& it, wxDList<T>& l)
- { splice(it, l, l.begin(), l.end() ); }
- void splice(const iterator& it, wxDList<T>& l, const iterator& first)
- {
- iterator tmp = first; ++tmp;
- if(it == first || it == tmp) return;
- insert(it, *first);
- l.erase(first);
- }
- void remove(const_reference v)
- { DeleteObject(v); }
- void reverse()
- { Reverse(); }
- /* void swap(list<T>& l)
- {
- { size_t t = m_count; m_count = l.m_count; l.m_count = t; }
- { bool t = m_destroy; m_destroy = l.m_destroy; l.m_destroy = t; }
- { wxNodeBase* t = m_nodeFirst; m_nodeFirst = l.m_nodeFirst; l.m_nodeFirst = t; }
- { wxNodeBase* t = m_nodeLast; m_nodeLast = l.m_nodeLast; l.m_nodeLast = t; }
- { wxKeyType t = m_keyType; m_keyType = l.m_keyType; l.m_keyType = t; }
- } */
+
+ /* STL interface */
+public:
+ typedef size_t size_type;
+ typedef int difference_type;
+ typedef T* value_type;
+ typedef value_type& reference;
+ typedef const value_type& const_reference;
+
+ class iterator
+ {
+ public:
+ typedef nodetype Node;
+ typedef iterator itor;
+ typedef T* value_type;
+ typedef value_type* ptr_type;
+ typedef value_type& reference;
+
+ Node* m_node;
+ Node* m_init;
+ public:
+ 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 *m_node->GetDataPtr(); }
+ // ptrop
+ itor& operator++() { m_node = m_node->GetNext(); return *this; }
+ const itor operator++(int)
+ { itor tmp = *this; m_node = m_node->GetNext(); return tmp; }
+ itor& operator--()
+ {
+ m_node = m_node ? m_node->GetPrevious() : m_init;
+ return *this;
+ }
+ const itor operator--(int)
+ {
+ itor tmp = *this;
+ m_node = m_node ? m_node->GetPrevious() : m_init;
+ return tmp;
+ }
+ bool operator!=(const itor& it) const
+ { return it.m_node != m_node; }
+ bool operator==(const itor& it) const
+ { return it.m_node == m_node; }
+ };
+ class const_iterator
+ {
+ public:
+ typedef nodetype Node;
+ typedef T* value_type;
+ typedef const value_type& const_reference;
+ typedef const_iterator itor;
+ typedef value_type* ptr_type;
+
+ Node* m_node;
+ Node* m_init;
+ public:
+ typedef const_reference reference_type;
+ typedef const ptr_type pointer_type;
+
+ const_iterator(Node* node, Node* init)
+ : m_node(node), m_init(init) { }
+ const_iterator() : m_node(NULL), m_init(NULL) { }
+ const_iterator(const iterator& it)
+ : m_node(it.m_node), m_init(it.m_init) { }
+ reference_type operator*() const
+ { return *m_node->GetDataPtr(); }
+ // ptrop
+ itor& operator++() { m_node = m_node->GetNext(); return *this; }
+ const itor operator++(int)
+ { itor tmp = *this; m_node = m_node->GetNext(); return tmp; }
+ itor& operator--()
+ {
+ m_node = m_node ? m_node->GetPrevious() : m_init;
+ return *this;
+ }
+ const itor operator--(int)
+ {
+ itor tmp = *this;
+ m_node = m_node ? m_node->GetPrevious() : m_init;
+ return tmp;
+ }
+ bool operator!=(const itor& it) const
+ { return it.m_node != m_node; }
+ bool operator==(const itor& it) const
+ { return it.m_node == m_node; }
+ };
+
+ class reverse_iterator
+ {
+ public:
+ typedef nodetype Node;
+ typedef T* value_type;
+ typedef reverse_iterator itor;
+ typedef value_type* ptr_type;
+ typedef value_type& reference;
+
+ Node* m_node;
+ Node* m_init;
+ public:
+ typedef reference reference_type;
+ typedef ptr_type pointer_type;
+
+ reverse_iterator(Node* node, Node* init)
+ : m_node(node), m_init(init) { }
+ reverse_iterator() : m_node(NULL), m_init(NULL) { }
+ reference_type operator*() const
+ { return *m_node->GetDataPtr(); }
+ // ptrop
+ itor& operator++()
+ { m_node = m_node->GetPrevious(); return *this; }
+ const itor operator++(int)
+ { itor tmp = *this; m_node = m_node->GetPrevious(); return tmp; }
+ itor& operator--()
+ { m_node = m_node ? m_node->GetNext() : m_init; return *this; }
+ const itor operator--(int)
+ {
+ itor tmp = *this;
+ m_node = m_node ? m_node->GetNext() : m_init;
+ return tmp;
+ }
+ bool operator!=(const itor& it) const
+ { return it.m_node != m_node; }
+ bool operator==(const itor& it) const
+ { return it.m_node == m_node; }
+ };
+
+ class const_reverse_iterator
+ {
+ public:
+ typedef nodetype Node;
+ typedef T* value_type;
+ typedef const_reverse_iterator itor;
+ typedef value_type* ptr_type;
+ typedef const value_type& const_reference;
+
+ Node* m_node;
+ Node* m_init;
+ public:
+ typedef const_reference reference_type;
+ typedef const ptr_type pointer_type;
+
+ const_reverse_iterator(Node* node, Node* init)
+ : m_node(node), m_init(init) { }
+ const_reverse_iterator() : m_node(NULL), m_init(NULL) { }
+ const_reverse_iterator(const reverse_iterator& it)
+ : m_node(it.m_node), m_init(it.m_init) { }
+ reference_type operator*() const
+ { return *m_node->GetDataPtr(); }
+ // ptrop
+ itor& operator++()
+ { m_node = m_node->GetPrevious(); return *this; }
+ const itor operator++(int)
+ { itor tmp = *this; m_node = m_node->GetPrevious(); return tmp; }
+ itor& operator--()
+ { m_node = m_node ? m_node->GetNext() : m_init; return *this;}
+ const itor operator--(int)
+ {
+ itor tmp = *this;
+ m_node = m_node ? m_node->GetNext() : m_init;
+ return tmp;
+ }
+ bool operator!=(const itor& it) const
+ { return it.m_node != m_node; }
+ bool operator==(const itor& it) const
+ { return it.m_node == m_node; }
+ };
+
+ wxEXPLICIT wxDList(size_type n, const_reference v = value_type())
+ { assign(n, v); }
+ wxDList(const const_iterator& first, const const_iterator& last)
+ { assign(first, last); }
+ iterator begin() { return iterator(GetFirst(), GetLast()); }
+ const_iterator begin() const
+ { return const_iterator(GetFirst(), GetLast()); }
+ iterator end() { return iterator(NULL, GetLast()); }
+ const_iterator end() const { return const_iterator(NULL, GetLast()); }
+ reverse_iterator rbegin()
+ { return reverse_iterator(GetLast(), GetFirst()); }
+ const_reverse_iterator rbegin() const
+ { return const_reverse_iterator(GetLast(), GetFirst()); }
+ reverse_iterator rend() { return reverse_iterator(NULL, GetFirst()); }
+ const_reverse_iterator rend() const
+ { return const_reverse_iterator(NULL, GetFirst()); }
+ void resize(size_type n, value_type v = value_type())
+ {
+ 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; }
+ bool empty() const { return IsEmpty(); }
+ reference front() { return *begin(); }
+ const_reference front() const { return *begin(); }
+ reference back() { iterator tmp = end(); return *--tmp; }
+ const_reference back() const { const_iterator tmp = end(); return *--tmp; }
+ void push_front(const_reference v = value_type())
+ { Insert(GetFirst(), v); }
+ void pop_front() { DeleteNode(GetFirst()); }
+ void push_back(const_reference v = value_type())
+ { Append( v ); }
+ void pop_back() { DeleteNode(GetLast()); }
+ void assign(const_iterator first, const const_iterator& last)
+ {
+ clear();
+ for(; first != last; ++first)
+ Append(*first);
+ }
+ void assign(size_type n, const_reference v = value_type())
+ {
+ clear();
+ for(size_type i = 0; i < n; ++i)
+ Append(v);
+ }
+ iterator insert(const iterator& it, const_reference v)
+ {
+ if (it == end())
+ Append( v );
+ else
+ Insert(it.m_node,v);
+ iterator itprev(it);
+ return itprev--;
+ }
+ void insert(const iterator& it, size_type n, const_reference v)
+ {
+ for(size_type i = 0; i < n; ++i)
+ Insert(it.m_node, v);
+ }
+ void insert(const iterator& it, const_iterator first, const const_iterator& last)
+ {
+ for(; first != last; ++first)
+ Insert(it.m_node, *first);
+ }
+ iterator erase(const iterator& it)
+ {
+ iterator next = iterator(it.m_node->GetNext(), GetLast());
+ DeleteNode(it.m_node); return next;
+ }
+ iterator erase(const iterator& first, const iterator& last)
+ {
+ iterator next = last; ++next;
+ DeleteNodes(first.m_node, last.m_node);
+ return next;
+ }
+ void clear() { Clear(); }
+ void splice(const iterator& it, wxDList<T>& l, const iterator& first, const iterator& last)
+ { insert(it, first, last); l.erase(first, last); }
+ void splice(const iterator& it, wxDList<T>& l)
+ { splice(it, l, l.begin(), l.end() ); }
+ void splice(const iterator& it, wxDList<T>& l, const iterator& first)
+ {
+ iterator tmp = first; ++tmp;
+ if(it == first || it == tmp) return;
+ insert(it, *first);
+ l.erase(first);
+ }
+ void remove(const_reference v)
+ { DeleteObject(v); }
+ void reverse()
+ { Reverse(); }
+ /* void swap(list<T>& l)
+ {
+ { size_t t = m_count; m_count = l.m_count; l.m_count = t; }
+ { bool t = m_destroy; m_destroy = l.m_destroy; l.m_destroy = t; }
+ { wxNodeBase* t = m_nodeFirst; m_nodeFirst = l.m_nodeFirst; l.m_nodeFirst = t; }
+ { wxNodeBase* t = m_nodeLast; m_nodeLast = l.m_nodeLast; l.m_nodeLast = t; }
+ { wxKeyType t = m_keyType; m_keyType = l.m_keyType; l.m_keyType = t; }
+ } */
};
-#endif
+#endif // wxUSE_STD_CONTAINERS/!wxUSE_STD_CONTAINERS
#endif // _WX_DLIST_H_
projects / wxWidgets.git / blobdiff