disable (some) features that are not available in DirectFB

[wxWidgets.git] / include / wx / list.h

diff --git a/include/wx/list.h b/include/wx/list.h
index 904bdfc5bacc7dbc753805d3221edc6b79f1a506..4a8541d37208fa617b0c823cdd9afcda666f2cf3 100644 (file)
--- a/include/wx/list.h
+++ b/include/wx/list.h
@@ -136,7 +136,7 @@ private:
 #endif // defined( __VISUALC__ )
 
 /*
 #endif // defined( __VISUALC__ )
 
 /*

-    Note: the outer helper class _WX_LIST_HELPER_##liT below is a workaround
+    Note 1: the outer helper class _WX_LIST_HELPER_##liT below is a workaround

     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:
 
     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:
 


@@ -155,11 +155,18 @@ private:
 
     The program does not link under mingw_gcc 3.2.3 producing undefined
     reference to Foo::Bar() function
 
     The program does not link under mingw_gcc 3.2.3 producing undefined
     reference to Foo::Bar() function

+
+
+    Note 2: the EmptyList is needed to allow having a NULL pointer-like
+    invalid iterator. We used to use just an uninitialized iterator object
+    instead but this fails with some debug/checked versions of STL, notably the
+    glibc version activated with _GLIBCXX_DEBUG, so we need to have a separate
+    invalid iterator.

  */
 
 // the real wxList-class declaration
 #define WX_DECLARE_LIST_XO(elT, liT, decl)                                    \
  */
 
 // the real wxList-class declaration
 #define WX_DECLARE_LIST_XO(elT, liT, decl)                                    \

-    class WXDLLEXPORT _WX_LIST_HELPER_##liT                                   \
+    decl _WX_LIST_HELPER_##liT                                                \

     {                                                                         \
         typedef elT _WX_LIST_ITEM_TYPE_##liT;                                 \
     public:                                                                   \
     {                                                                         \
         typedef elT _WX_LIST_ITEM_TYPE_##liT;                                 \
     public:                                                                   \


@@ -170,20 +177,25 @@ private:
     decl liT : public std::list<elT>                                          \
     {                                                                         \
     private:                                                                  \
     decl liT : public std::list<elT>                                          \
     {                                                                         \
     private:                                                                  \

+        typedef std::list<elT> BaseListType;                                  \
+        static BaseListType EmptyList;                                        \
+                                                                              \

         bool m_destroy;                                                       \
         bool m_destroy;                                                       \

+                                                                              \

     public:                                                                   \
         decl compatibility_iterator                                           \
         {                                                                     \
         private:                                                              \
     public:                                                                   \
         decl compatibility_iterator                                           \
         {                                                                     \
         private:                                                              \

-          /* Workaround for broken VC6 nested class name resolution */        \
-          typedef std::list<elT>::iterator iterator;                          \
-          friend class liT;                                                   \
-        private:                                                              \
+            /* Workaround for broken VC6 nested class name resolution */      \
+            typedef std::list<elT>::iterator iterator;                        \
+            friend class liT;                                                 \
+                                                                              \

             iterator m_iter;                                                  \
             liT * m_list;                                                     \
             iterator m_iter;                                                  \
             liT * m_list;                                                     \

+                                                                              \

         public:                                                               \
             compatibility_iterator()                                          \
         public:                                                               \
             compatibility_iterator()                                          \

-                : m_iter(), m_list( NULL ) {}                                 \
+                : m_iter(EmptyList.end()), m_list( NULL ) {}                  \

             compatibility_iterator( liT* li, iterator i )                     \
                 : m_iter( i ), m_list( li ) {}                                \
             compatibility_iterator( const liT* li, iterator i )               \
             compatibility_iterator( liT* li, iterator i )                     \
                 : m_iter( i ), m_list( li ) {}                                \
             compatibility_iterator( const liT* li, iterator i )               \


@@ -252,6 +264,11 @@ private:
             std::advance( i, idx );                                           \
             return compatibility_iterator( this, i );                         \
         }                                                                     \
             std::advance( i, idx );                                           \
             return compatibility_iterator( this, i );                         \
         }                                                                     \

+        elT operator[](size_t idx) const                                      \
+        {                                                                     \
+            return Item(idx).GetData();                                       \
+        }                                                                     \
+                                                                              \

         compatibility_iterator GetFirst() const                               \
         {                                                                     \
             return compatibility_iterator( this,                              \
         compatibility_iterator GetFirst() const                               \
         {                                                                     \
             return compatibility_iterator( this,                              \


@@ -323,6 +340,9 @@ private:
         void Sort( wxSortCompareFunction compfunc )                           \
             { sort( WX_LIST_SORTFUNCTION( elT, compfunc ) ); }                \
         ~liT() { Clear(); }                                                   \
         void Sort( wxSortCompareFunction compfunc )                           \
             { sort( WX_LIST_SORTFUNCTION( elT, compfunc ) ); }                \
         ~liT() { Clear(); }                                                   \

+                                                                              \
+        /* It needs access to our EmptyList */                                \
+        friend decl compatibility_iterator;                                   \

     }
 
 #define WX_DECLARE_LIST(elementtype, listname)                              \
     }
 
 #define WX_DECLARE_LIST(elementtype, listname)                              \


@@ -730,12 +750,12 @@ private:
         name& operator=(const name& list)                                   \
             { Assign(list); return *this; }                                 \
                                                                             \
         name& operator=(const name& list)                                   \
             { Assign(list); return *this; }                                 \
                                                                             \

-        compatibility_iterator GetFirst() const                             \
+        nodetype *GetFirst() const                                          \

             { return (nodetype *)wxListBase::GetFirst(); }                  \
             { return (nodetype *)wxListBase::GetFirst(); }                  \

-        compatibility_iterator GetLast() const                              \
+        nodetype *GetLast() const                                           \

             { return (nodetype *)wxListBase::GetLast(); }                   \
                                                                             \
             { return (nodetype *)wxListBase::GetLast(); }                   \
                                                                             \

-        compatibility_iterator Item(size_t index) const                     \
+        nodetype *Item(size_t index) const                                  \

             { return (nodetype *)wxListBase::Item(index); }                 \
                                                                             \
         T *operator[](size_t index) const                                   \
             { return (nodetype *)wxListBase::Item(index); }                 \
                                                                             \
         T *operator[](size_t index) const                                   \


@@ -744,18 +764,18 @@ private:
             return node ? (T*)(node->GetData()) : (T*)NULL;                 \
         }                                                                   \
                                                                             \
             return node ? (T*)(node->GetData()) : (T*)NULL;                 \
         }                                                                   \
                                                                             \

-        compatibility_iterator Append(Tbase *object)                        \
+        nodetype *Append(Tbase *object)                                     \

             { return (nodetype *)wxListBase::Append(object); }              \
             { return (nodetype *)wxListBase::Append(object); }              \

-        compatibility_iterator Insert(Tbase *object)                        \
+        nodetype *Insert(Tbase *object)                                     \

             { return (nodetype *)Insert((nodetype*)NULL, object); }         \
             { return (nodetype *)Insert((nodetype*)NULL, object); }         \

-        compatibility_iterator Insert(size_t pos, Tbase *object)            \
+        nodetype *Insert(size_t pos, Tbase *object)                         \

             { return (nodetype *)wxListBase::Insert(pos, object); }         \
             { return (nodetype *)wxListBase::Insert(pos, object); }         \

-        compatibility_iterator Insert(nodetype *prev, Tbase *object)        \
+        nodetype *Insert(nodetype *prev, Tbase *object)                     \

             { return (nodetype *)wxListBase::Insert(prev, object); }        \
                                                                             \
             { return (nodetype *)wxListBase::Insert(prev, object); }        \
                                                                             \

-        compatibility_iterator Append(long key, void *object)               \
+        nodetype *Append(long key, void *object)                            \

             { return (nodetype *)wxListBase::Append(key, object); }         \
             { return (nodetype *)wxListBase::Append(key, object); }         \

-        compatibility_iterator Append(const wxChar *key, void *object)      \
+        nodetype *Append(const wxChar *key, void *object)                   \

             { return (nodetype *)wxListBase::Append(key, object); }         \
                                                                             \
         nodetype *DetachNode(nodetype *node)                                \
             { return (nodetype *)wxListBase::Append(key, object); }         \
                                                                             \
         nodetype *DetachNode(nodetype *node)                                \


@@ -764,10 +784,10 @@ private:
             { return wxListBase::DeleteNode(node); }                        \
         bool DeleteObject(Tbase *object)                                    \
             { return wxListBase::DeleteObject(object); }                    \
             { return wxListBase::DeleteNode(node); }                        \
         bool DeleteObject(Tbase *object)                                    \
             { return wxListBase::DeleteObject(object); }                    \

-        void Erase(compatibility_iterator it)                               \
+        void Erase(nodetype *it)                                            \

             { DeleteNode(it); }                                             \
                                                                             \
             { DeleteNode(it); }                                             \
                                                                             \

-        compatibility_iterator Find(const Tbase *object) const              \
+        nodetype *Find(const Tbase *object) const                           \

             { return (nodetype *)wxListBase::Find(object); }                \
                                                                             \
         virtual nodetype *Find(const wxListKey& key) const                  \
             { return (nodetype *)wxListBase::Find(object); }                \
                                                                             \
         virtual nodetype *Find(const wxListKey& key) const                  \