added "access" parameter to wxFile::Create and Open. The default value is

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

diff --git a/include/wx/dynarray.h b/include/wx/dynarray.h
index a73954ae7365bb0ed9d9b170246668673af474d7..37e106f5f2e6ffab4d1ff996f68dc8853ffb2d1c 100644 (file)
--- a/include/wx/dynarray.h
+++ b/include/wx/dynarray.h
@@ -2,7 +2,7 @@
 // Name:        dynarray.h
 // Purpose:     auto-resizable (i.e. dynamic) array support
 // Author:      Vadim Zeitlin
 // Name:        dynarray.h
 // Purpose:     auto-resizable (i.e. dynamic) array support
 // Author:      Vadim Zeitlin

-// Modified by: 
+// Modified by:

 // Created:     12.09.97
 // RCS-ID:      $Id$
 // Copyright:   (c) 1998 Vadim Zeitlin <zeitlin@dptmaths.ens-cachan.fr>
 // Created:     12.09.97
 // RCS-ID:      $Id$
 // Copyright:   (c) 1998 Vadim Zeitlin <zeitlin@dptmaths.ens-cachan.fr>


@@ -17,9 +17,9 @@
 #endif
 
 #include "wx/defs.h"
 #endif
 
 #include "wx/defs.h"

-#include "wx/utils.h"
+#include "wx/debug.h"

 
 

-/** @name Dynamic arrays and lists 
+/** @name Dynamic arrays and lists

     @memo Arrays which grow on demand and do range checking (only in debug)
   */
 //@{
     @memo Arrays which grow on demand and do range checking (only in debug)
   */
 //@{


@@ -30,7 +30,7 @@
 
 /**
  the initial size by which an array/list grows when an element is added
 
 /**
  the initial size by which an array/list grows when an element is added

- default value avoids allocate one or two bytes when the array is created 
+ default value avoids allocate one or two bytes when the array is created

  which is rather inefficient
 */
 #define   WX_ARRAY_DEFAULT_INITIAL_SIZE    (16)
  which is rather inefficient
 */
 #define   WX_ARRAY_DEFAULT_INITIAL_SIZE    (16)


@@ -41,7 +41,7 @@
 
 /**
  callback compare function for quick sort
 
 /**
  callback compare function for quick sort

- must return -1, 0 or +1 if pItem1 <, = or > pItem2
+ must return negative value, 0 or positive value if pItem1 <, = or > pItem2

  */
 
 #ifdef  __VISUALC__
  */
 
 #ifdef  __VISUALC__


@@ -56,9 +56,9 @@ typedef int (CMPFUNC_CONV *CMPFUNC)(const void* pItem1, const void* pItem2);
  base class managing data having size of type 'long' (not used directly)
 
  NB: for efficiency this often used class has no virtual functions (hence no
  base class managing data having size of type 'long' (not used directly)
 
  NB: for efficiency this often used class has no virtual functions (hence no

-     VTBL), even dtor is <B>not</B> virtual. If used as expected it won't 
-     create any problems because ARRAYs from DEFINE_ARRAY have no dtor at all, 
-     so it's not too important if it's not called (this happens when you cast 
+     VTBL), even dtor is <B>not</B> virtual. If used as expected it won't
+     create any problems because ARRAYs from DEFINE_ARRAY have no dtor at all,
+     so it's not too important if it's not called (this happens when you cast

      "SomeArray *" as "BaseArray *" and then delete it)
 
   @memo Base class for template array and list classes
      "SomeArray *" as "BaseArray *" and then delete it)
 
   @memo Base class for template array and list classes


@@ -102,7 +102,7 @@ public:
   //@}
 
 protected:
   //@}
 
 protected:

-  // these methods are protected because if they were public one could 
+  // these methods are protected because if they were public one could

   // mistakenly call one of them instead of DEFINE_ARRAY's or LIST's
   // type safe methods
 
   // mistakenly call one of them instead of DEFINE_ARRAY's or LIST's
   // type safe methods
 


@@ -123,10 +123,14 @@ protected:
       @return index of the first item matched or NOT_FOUND
       @see NOT_FOUND
      */
       @return index of the first item matched or NOT_FOUND
       @see NOT_FOUND
      */

-  int  Index (long lItem, bool bFromEnd = FALSE) const;
+  int Index(long lItem, bool bFromEnd = FALSE) const;
+    /// search for an item using binary search in a sorted array
+  int Index(long lItem, CMPFUNC fnCompare) const;

     /// add new element at the end
     /// add new element at the end

-  void Add   (long lItem);
-    /// add new element at given position
+  void Add(long lItem);
+    /// add item assuming the array is sorted with fnCompare function
+  void Add(long lItem, CMPFUNC fnCompare);
+    /// add new element at given position (it becomes Item[uiIndex])

   void Insert(long lItem, uint uiIndex);
     /// remove first item matching this value
   void Remove(long lItem);
   void Insert(long lItem, uint uiIndex);
     /// remove first item matching this value
   void Remove(long lItem);


@@ -135,7 +139,7 @@ protected:
   //@}
 
   /// sort array elements using given compare function
   //@}
 
   /// sort array elements using given compare function

-  void Sort(CMPFUNC fCmp);
+  void Sort(CMPFUNC fnCompare);

 
 private:
   void    Grow();     // makes array bigger if needed
 
 private:
   void    Grow();     // makes array bigger if needed


@@ -153,7 +157,7 @@ private:
 // ----------------------------------------------------------------------------
 // This macro generates a new array class. It is intended for storage of simple
 // types of sizeof()<=sizeof(long) or pointers if sizeof(pointer)<=sizeof(long)
 // ----------------------------------------------------------------------------
 // This macro generates a new array class. It is intended for storage of simple
 // types of sizeof()<=sizeof(long) or pointers if sizeof(pointer)<=sizeof(long)

-// 
+//

 // NB: it has only inline functions => takes no space at all
 // ----------------------------------------------------------------------------
 #define  _WX_DEFINE_ARRAY(T, name)                                  \
 // NB: it has only inline functions => takes no space at all
 // ----------------------------------------------------------------------------
 #define  _WX_DEFINE_ARRAY(T, name)                                  \


@@ -172,6 +176,8 @@ public:                                                             \
     { return (T&)(wxBaseArray::Item(uiIndex)); }                    \
   T& Item(uint uiIndex) const                                       \
     { return (T&)(wxBaseArray::Item(uiIndex)); }                    \
     { return (T&)(wxBaseArray::Item(uiIndex)); }                    \
   T& Item(uint uiIndex) const                                       \
     { return (T&)(wxBaseArray::Item(uiIndex)); }                    \

+  T& Last() const                                                   \
+    { return (T&)(wxBaseArray::Item(Count() - 1)); }                \

                                                                     \
   int Index(T Item, bool bFromEnd = FALSE) const                    \
     { return wxBaseArray::Index((long)Item, bFromEnd); }            \
                                                                     \
   int Index(T Item, bool bFromEnd = FALSE) const                    \
     { return wxBaseArray::Index((long)Item, bFromEnd); }            \


@@ -191,6 +197,60 @@ public:                                                             \
   void Sort(CMPFUNC##T fCmp) { wxBaseArray::Sort((CMPFUNC)fCmp); }  \
 }
 
   void Sort(CMPFUNC##T fCmp) { wxBaseArray::Sort((CMPFUNC)fCmp); }  \
 }
 

+// ----------------------------------------------------------------------------
+// This is the same as the previous macro, but it defines a sorted array.
+// Differences:
+//  1) it must be given a COMPARE function in ctor which takes 2 items of type
+//     T* and should return -1, 0 or +1 if the first one is less/greater
+//     than/equal to the second one.
+//  2) the Add() method inserts the item in such was that the array is always
+//     sorted (it uses the COMPARE function)
+//  3) it has no Sort() method because it's always sorted
+//  4) Index() method is much faster (the sorted arrays use binary search
+//     instead of linear one), but Add() is slower.
+//
+// Summary: use this class when the speed of Index() function is important, use
+// the normal arrays otherwise.
+//
+// NB: it has only inline functions => takes no space at all
+// ----------------------------------------------------------------------------
+#define  _WX_DEFINE_SORTED_ARRAY(T, name)                           \
+typedef int (CMPFUNC_CONV *SCMPFUNC##T)(T pItem1, T pItem2);        \
+class name : public wxBaseArray                                     \
+{                                                                   \
+public:                                                             \
+  name(SCMPFUNC##T fn)                                              \
+    { wxASSERT( sizeof(T) <= sizeof(long) ); m_fnCompare = fn; }    \
+                                                                    \
+  name& operator=(const name& src)                                  \
+    { ((wxBaseArray *)this)->operator=((const wxBaseArray&)src);    \
+      m_fnCompare = src.m_fnCompare;                                \
+      return *this; }                                               \
+                                                                    \
+  T& operator[](uint uiIndex) const                                 \
+    { return (T&)(wxBaseArray::Item(uiIndex)); }                    \
+  T& Item(uint uiIndex) const                                       \
+    { return (T&)(wxBaseArray::Item(uiIndex)); }                    \
+  T& Last() const                                                   \
+    { return (T&)(wxBaseArray::Item(Count() - 1)); }                \
+                                                                    \
+  int Index(T Item) const                                           \
+    { return wxBaseArray::Index((long)Item, (CMPFUNC)m_fnCompare); }\
+                                                                    \
+  void Add(T Item)                                                  \
+    { wxBaseArray::Add((long)Item, (CMPFUNC)m_fnCompare); }         \
+                                                                    \
+  void Remove(uint uiIndex) { wxBaseArray::Remove(uiIndex); }       \
+  void Remove(T Item)                                               \
+    { int iIndex = Index(Item);                                     \
+      wxCHECK2_MSG( iIndex != NOT_FOUND, return,                    \
+        "removing inexisting element in wxArray::Remove" );         \
+      wxBaseArray::Remove((uint)iIndex); }                          \
+                                                                    \
+private:                                                            \
+  SCMPFUNC##T m_fnCompare;                                          \
+}
+

 // ----------------------------------------------------------------------------
 // see WX_DECLARE_LIST and WX_DEFINE_LIST
 // ----------------------------------------------------------------------------
 // ----------------------------------------------------------------------------
 // see WX_DECLARE_LIST and WX_DEFINE_LIST
 // ----------------------------------------------------------------------------


@@ -209,6 +269,8 @@ public:                                                             \
     { return *(T*)wxBaseArray::Item(uiIndex); }                     \
   T& Item(uint uiIndex) const                                       \
     { return *(T*)wxBaseArray::Item(uiIndex); }                     \
     { return *(T*)wxBaseArray::Item(uiIndex); }                     \
   T& Item(uint uiIndex) const                                       \
     { return *(T*)wxBaseArray::Item(uiIndex); }                     \

+  T& Last() const                                                   \
+    { return *(T*)(wxBaseArray::Item(Count() - 1)); }               \

                                                                     \
   int Index(const T& Item, bool bFromEnd = FALSE) const;            \
                                                                     \
                                                                     \
   int Index(const T& Item, bool bFromEnd = FALSE) const;            \
                                                                     \


@@ -234,7 +296,7 @@ private:                                                            \
 }
 
 // ----------------------------------------------------------------------------
 }
 
 // ----------------------------------------------------------------------------

-/** @name Macros for definition of dynamic arrays and lists 
+/** @name Macros for definition of dynamic arrays and lists

 
   These macros are ugly (especially if you look in the sources ;-), but they
   allow us to define 'template' classes without actually using templates.
 
   These macros are ugly (especially if you look in the sources ;-), but they
   allow us to define 'template' classes without actually using templates.


@@ -243,7 +305,7 @@ private:                                                            \
   Range checking is performed in debug build for both arrays and lists. Type
   checking is done at compile-time. Warning: arrays <I>never</I> shrink, they
   only grow, so loading 10 millions in an array only to delete them 2 lines
   Range checking is performed in debug build for both arrays and lists. Type
   checking is done at compile-time. Warning: arrays <I>never</I> shrink, they
   only grow, so loading 10 millions in an array only to delete them 2 lines

-  below is <I>not</I> recommended. However, it does free memory when it's 
+  below is <I>not</I> recommended. However, it does free memory when it's

   destroyed, so if you destroy array also, it's ok.
   */
 // ----------------------------------------------------------------------------
   destroyed, so if you destroy array also, it's ok.
   */
 // ----------------------------------------------------------------------------


@@ -260,6 +322,14 @@ private:                                                            \
   */
 #define WX_DEFINE_ARRAY(T, name)  typedef T _A##name;                        \
                                   _WX_DEFINE_ARRAY(_A##name, name)
   */
 #define WX_DEFINE_ARRAY(T, name)  typedef T _A##name;                        \
                                   _WX_DEFINE_ARRAY(_A##name, name)

+
+  /**
+   This macro does the same as WX_DEFINE_ARRAY except that the array will be
+   sorted with the specified compare function.
+   */
+#define WX_DEFINE_SORTED_ARRAY(T, name)  typedef T _A##name;                 \
+                                  _WX_DEFINE_SORTED_ARRAY(_A##name, name)
+

   /**
    This macro generates a new list class which owns the objects it contains,
    i.e. it will delete them when it is destroyed. An element is of type T*,
   /**
    This macro generates a new list class which owns the objects it contains,
    i.e. it will delete them when it is destroyed. An element is of type T*,


@@ -286,11 +356,11 @@ private:                                                            \
    <BR>
    NB1: Base type T should have an accessible copy ctor  if  Add(T&) is used,
    <BR>
    <BR>
    NB1: Base type T should have an accessible copy ctor  if  Add(T&) is used,
    <BR>

-   NB2: Never ever cast a list to it's base type: as dtor is <B>not</B> virtual 
+   NB2: Never ever cast a list to it's base type: as dtor is <B>not</B> virtual

         it will provoke memory leaks
    <BR>
    <BR>
         it will provoke memory leaks
    <BR>
    <BR>

-   some functions of this class are not inline, so it takes some space to 
+   some functions of this class are not inline, so it takes some space to

    define new class from this template.
 
    @memo declare list class 'name' containing elements of type 'T'
    define new class from this template.
 
    @memo declare list class 'name' containing elements of type 'T'


@@ -309,7 +379,7 @@ private:                                                            \
     This is necessary because at the moment of DEFINE_LIST class element_type
     must be fully defined (i.e. forward declaration is not enough), while
     DECLARE_LIST may be done anywhere. The separation of two allows to break
     This is necessary because at the moment of DEFINE_LIST class element_type
     must be fully defined (i.e. forward declaration is not enough), while
     DECLARE_LIST may be done anywhere. The separation of two allows to break

-    cicrcular dependencies with classes which have member variables of list 
+    cicrcular dependencies with classes which have member variables of list

     type.
 
     @memo define (must include listimpl.cpp!) list class 'name'
     type.
 
     @memo define (must include listimpl.cpp!) list class 'name'