Make wxRichTextRectArray usable by other parts of wxRTC

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

diff --git a/include/wx/list.h b/include/wx/list.h
index a84ee041bb9ed63357e60220e46eb01d05f6d4db..160b3b8ba46f5dcf84a1446de30dd3b7af018026 100644 (file)
--- a/include/wx/list.h
+++ b/include/wx/list.h
@@ -4,7 +4,6 @@
 // Author:      Julian Smart
 // Modified by: VZ at 16/11/98: WX_DECLARE_LIST() and typesafe lists added
 // Created:     29/01/98
 // Author:      Julian Smart
 // 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 licence
 /////////////////////////////////////////////////////////////////////////////
 // Copyright:   (c) 1998 Julian Smart
 // Licence:     wxWindows licence
 /////////////////////////////////////////////////////////////////////////////


@@ -32,8 +31,9 @@
 #include "wx/defs.h"
 #include "wx/object.h"
 #include "wx/string.h"
 #include "wx/defs.h"
 #include "wx/object.h"
 #include "wx/string.h"

+#include "wx/vector.h"

 
 

-#if wxUSE_STL
+#if wxUSE_STD_CONTAINERS

     #include "wx/beforestd.h"
     #include <algorithm>
     #include <iterator>
     #include "wx/beforestd.h"
     #include <algorithm>
     #include <iterator>


@@ -48,7 +48,7 @@
 class WXDLLIMPEXP_FWD_BASE wxObjectListNode;
 typedef wxObjectListNode wxNode;
 
 class WXDLLIMPEXP_FWD_BASE wxObjectListNode;
 typedef wxObjectListNode wxNode;
 

-#if wxUSE_STL
+#if wxUSE_STD_CONTAINERS

 
 #define wxLIST_COMPATIBILITY
 
 
 #define wxLIST_COMPATIBILITY
 


@@ -148,21 +148,22 @@ inline const void *wxListCastElementToVoidPtr(const wxString& str)
     decl _WX_LIST_HELPER_##liT                                                \
     {                                                                         \
         typedef elT _WX_LIST_ITEM_TYPE_##liT;                                 \
     decl _WX_LIST_HELPER_##liT                                                \
     {                                                                         \
         typedef elT _WX_LIST_ITEM_TYPE_##liT;                                 \

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

     public:                                                                   \
     public:                                                                   \

+        static BaseListType EmptyList;                                        \

         static void DeleteFunction( _WX_LIST_ITEM_TYPE_##liT X );             \
     };                                                                        \
                                                                               \
     WX_LIST_VC6_WORKAROUND(elT, liT, decl)                                    \
         static void DeleteFunction( _WX_LIST_ITEM_TYPE_##liT X );             \
     };                                                                        \
                                                                               \
     WX_LIST_VC6_WORKAROUND(elT, liT, decl)                                    \

-    decl liT : public std::list<elT>                                          \
+    class liT : public std::list<elT>                                          \

     {                                                                         \
     private:                                                                  \
         typedef std::list<elT> BaseListType;                                  \
     {                                                                         \
     private:                                                                  \
         typedef std::list<elT> BaseListType;                                  \

-        static BaseListType EmptyList;                                        \

                                                                               \
         bool m_destroy;                                                       \
                                                                               \
     public:                                                                   \
                                                                               \
         bool m_destroy;                                                       \
                                                                               \
     public:                                                                   \

-        decl compatibility_iterator                                           \
+        class compatibility_iterator                                           \

         {                                                                     \
         private:                                                              \
             /* Workaround for broken VC6 nested class name resolution */      \
         {                                                                     \
         private:                                                              \
             /* Workaround for broken VC6 nested class name resolution */      \


@@ -174,7 +175,7 @@ inline const void *wxListCastElementToVoidPtr(const wxString& str)
                                                                               \
         public:                                                               \
             compatibility_iterator()                                          \
                                                                               \
         public:                                                               \
             compatibility_iterator()                                          \

-                : m_iter(EmptyList.end()), m_list( NULL ) {}                  \
+                : m_iter(_WX_LIST_HELPER_##liT::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 )               \


@@ -216,7 +217,7 @@ inline const void *wxListCastElementToVoidPtr(const wxString& str)
             }                                                                 \
             int IndexOf() const                                               \
             {                                                                 \
             }                                                                 \
             int IndexOf() const                                               \
             {                                                                 \

-                return *this ? std::distance( m_list->begin(), m_iter )       \
+                return *this ? (int)std::distance( m_list->begin(), m_iter )  \

                              : wxNOT_FOUND;                                   \
             }                                                                 \
         };                                                                    \
                              : wxNOT_FOUND;                                   \
             }                                                                 \
         };                                                                    \


@@ -346,7 +347,7 @@ inline const void *wxListCastElementToVoidPtr(const wxString& str)
 #define WX_DEFINE_EXPORTED_LIST(name)      WX_DEFINE_LIST(name)
 #define WX_DEFINE_USER_EXPORTED_LIST(name) WX_DEFINE_LIST(name)
 
 #define WX_DEFINE_EXPORTED_LIST(name)      WX_DEFINE_LIST(name)
 #define WX_DEFINE_USER_EXPORTED_LIST(name) WX_DEFINE_LIST(name)
 

-#else // if !wxUSE_STL
+#else // if !wxUSE_STD_CONTAINERS

 
 
 // undef it to get rid of old, deprecated functions
 
 
 // undef it to get rid of old, deprecated functions


@@ -767,6 +768,9 @@ private:
         virtual nodetype *Find(const wxListKey& key) const                  \
             { return (nodetype *)wxListBase::Find(key); }                   \
                                                                             \
         virtual nodetype *Find(const wxListKey& key) const                  \
             { return (nodetype *)wxListBase::Find(key); }                   \
                                                                             \

+        bool Member(const Tbase *object) const                              \
+            { return Find(object) != NULL; }                                \
+                                                                            \

         int IndexOf(Tbase *object) const                                    \
             { return wxListBase::IndexOf(object); }                         \
                                                                             \
         int IndexOf(Tbase *object) const                                    \
             { return wxListBase::IndexOf(object); }                         \
                                                                             \


@@ -816,9 +820,19 @@ private:
             reference_type operator*() const                                \
                 { return *(pointer_type)m_node->GetDataPtr(); }             \
             ptrop                                                           \
             reference_type operator*() const                                \
                 { return *(pointer_type)m_node->GetDataPtr(); }             \
             ptrop                                                           \

-            itor& operator++() { m_node = m_node->GetNext(); return *this; }\
+            itor& operator++()                                              \
+            {                                                               \
+                wxASSERT_MSG( m_node, wxT("uninitialized iterator") );      \
+                m_node = m_node->GetNext();                                 \
+                return *this;                                               \
+            }                                                               \

             const itor operator++(int)                                      \
             const itor operator++(int)                                      \

-                { itor tmp = *this; m_node = m_node->GetNext(); return tmp; }\
+            {                                                               \
+                itor tmp = *this;                                           \
+                wxASSERT_MSG( m_node, wxT("uninitialized iterator") );      \
+                m_node = m_node->GetNext();                                 \
+                return tmp;                                                 \
+            }                                                               \

             itor& operator--()                                              \
             {                                                               \
                 m_node = m_node ? m_node->GetPrevious() : m_init;           \
             itor& operator--()                                              \
             {                                                               \
                 m_node = m_node ? m_node->GetPrevious() : m_init;           \


@@ -859,9 +873,19 @@ private:
             reference_type operator*() const                                \
                 { return *(pointer_type)m_node->GetDataPtr(); }             \
             ptrop                                                           \
             reference_type operator*() const                                \
                 { return *(pointer_type)m_node->GetDataPtr(); }             \
             ptrop                                                           \

-            itor& operator++() { m_node = m_node->GetNext(); return *this; }\
+            itor& operator++()                                              \
+            {                                                               \
+                wxASSERT_MSG( m_node, wxT("uninitialized iterator") );      \
+                m_node = m_node->GetNext();                                 \
+                return *this;                                               \
+            }                                                               \

             const itor operator++(int)                                      \
             const itor operator++(int)                                      \

-                { itor tmp = *this; m_node = m_node->GetNext(); return tmp; }\
+            {                                                               \
+                itor tmp = *this;                                           \
+                wxASSERT_MSG( m_node, wxT("uninitialized iterator") );      \
+                m_node = m_node->GetNext();                                 \
+                return tmp;                                                 \
+            }                                                               \

             itor& operator--()                                              \
             {                                                               \
                 m_node = m_node ? m_node->GetPrevious() : m_init;           \
             itor& operator--()                                              \
             {                                                               \
                 m_node = m_node ? m_node->GetPrevious() : m_init;           \


@@ -1010,11 +1034,22 @@ private:
         iterator insert(const iterator& it, const_reference v)              \
         {                                                                   \
             if ( it == end() )                                              \
         iterator insert(const iterator& it, const_reference v)              \
         {                                                                   \
             if ( it == end() )                                              \

+            {                                                               \

                 Append((const_base_reference)v);                            \
                 Append((const_base_reference)v);                            \

+                /*                                                          \
+                    note that this is the new end(), the old one was        \
+                    invalidated by the Append() call, and this is why we    \
+                    can't use the same code as in the normal case below     \
+                 */                                                         \
+                iterator itins(end());                                      \
+                return --itins;                                             \
+            }                                                               \

             else                                                            \
             else                                                            \

+            {                                                               \

                 Insert(it.m_node, (const_base_reference)v);                 \
                 Insert(it.m_node, (const_base_reference)v);                 \

-            iterator itprev(it);                                            \
-            return itprev--;                                                \
+                iterator itins(it);                                         \
+                return --itins;                                             \
+            }                                                               \

         }                                                                   \
         void insert(const iterator& it, size_type n, const_reference v)     \
         {                                                                   \
         }                                                                   \
         void insert(const iterator& it, size_type n, const_reference v)     \
         {                                                                   \


@@ -1114,7 +1149,7 @@ private:
 #define WX_DEFINE_EXPORTED_LIST(name)      WX_DEFINE_LIST(name)
 #define WX_DEFINE_USER_EXPORTED_LIST(name) WX_DEFINE_LIST(name)
 
 #define WX_DEFINE_EXPORTED_LIST(name)      WX_DEFINE_LIST(name)
 #define WX_DEFINE_USER_EXPORTED_LIST(name) WX_DEFINE_LIST(name)
 

-#endif // !wxUSE_STL
+#endif // !wxUSE_STD_CONTAINERS

 
 // ============================================================================
 // now we can define classes 100% compatible with the old ones
 
 // ============================================================================
 // now we can define classes 100% compatible with the old ones


@@ -1128,7 +1163,7 @@ private:
 
 // inline compatibility functions
 
 
 // inline compatibility functions
 

-#if !wxUSE_STL
+#if !wxUSE_STD_CONTAINERS

 
 // ----------------------------------------------------------------------------
 // wxNodeBase deprecated methods
 
 // ----------------------------------------------------------------------------
 // wxNodeBase deprecated methods


@@ -1163,27 +1198,43 @@ WX_DECLARE_LIST_2(wxObject, wxObjectList, wxObjectListNode,
 class WXDLLIMPEXP_BASE wxList : public wxObjectList
 {
 public:
 class WXDLLIMPEXP_BASE wxList : public wxObjectList
 {
 public:

-#if defined(wxWARN_COMPAT_LIST_USE) && !wxUSE_STL
-    wxList() { };
+#if defined(wxWARN_COMPAT_LIST_USE) && !wxUSE_STD_CONTAINERS
+    wxList() { }

     wxDEPRECATED( wxList(int key_type) );
     wxDEPRECATED( wxList(int key_type) );

-#elif !wxUSE_STL
+#elif !wxUSE_STD_CONTAINERS

     wxList(int key_type = wxKEY_NONE);
 #endif
 
     // this destructor is required for Darwin
    ~wxList() { }
 
     wxList(int key_type = wxKEY_NONE);
 #endif
 
     // this destructor is required for Darwin
    ~wxList() { }
 

-#if !wxUSE_STL
+#if !wxUSE_STD_CONTAINERS

     wxList& operator=(const wxList& list)
         { if (&list != this) Assign(list); return *this; }
 
     // compatibility methods
     void Sort(wxSortCompareFunction compfunc) { wxListBase::Sort(compfunc); }
     wxList& operator=(const wxList& list)
         { if (&list != this) Assign(list); return *this; }
 
     // compatibility methods
     void Sort(wxSortCompareFunction compfunc) { wxListBase::Sort(compfunc); }

-    bool Member(wxObject *object) const { return Find(object) != NULL; }
-#endif // !wxUSE_STL
+#endif // !wxUSE_STD_CONTAINERS
+
+#ifndef __VISUALC6__
+    template<typename T>
+    wxVector<T> AsVector() const
+    {
+        wxVector<T> vector(size());
+        size_t i = 0;
+
+        for ( const_iterator it = begin(); it != end(); ++it )
+        {
+            vector[i++] = static_cast<T>(*it);
+        }
+
+        return vector;
+    }
+#endif // !__VISUALC6__
+

 };
 
 };
 

-#if !wxUSE_STL
+#if !wxUSE_STD_CONTAINERS

 
 // -----------------------------------------------------------------------------
 // wxStringList class for compatibility with the old code
 
 // -----------------------------------------------------------------------------
 // wxStringList class for compatibility with the old code


@@ -1235,7 +1286,7 @@ private:
     void DoCopy(const wxStringList&); // common part of copy ctor and operator=
 };
 
     void DoCopy(const wxStringList&); // common part of copy ctor and operator=
 };
 

-#else // if wxUSE_STL
+#else // if wxUSE_STD_CONTAINERS

 
 WX_DECLARE_LIST_XO(wxString, wxStringListBase, class WXDLLIMPEXP_BASE);
 
 
 WX_DECLARE_LIST_XO(wxString, wxStringListBase, class WXDLLIMPEXP_BASE);
 


@@ -1258,7 +1309,7 @@ public:
         { push_front(s); return GetFirst(); }
 };
 
         { push_front(s); return GetFirst(); }
 };
 

-#endif // wxUSE_STL
+#endif // wxUSE_STD_CONTAINERS

 
 #endif // wxLIST_COMPATIBILITY
 
 
 #endif // wxLIST_COMPATIBILITY