include/wx/vector.h

   1 ///////////////////////////////////////////////////////////////////////////////
   2 // Name:        wx/vector.h
   3 // Purpose:     STL vector clone
   4 // Author:      Lindsay Mathieson
   5 // Modified by: Vaclav Slavik - make it a template
   6 // Created:     30.07.2001
   7 // Copyright:   (c) 2001 Lindsay Mathieson <lindsay@mathieson.org>,
   8 //                  2007 Vaclav Slavik <vslavik@fastmail.fm>
   9 // Licence:     wxWindows licence
  10 ///////////////////////////////////////////////////////////////////////////////
  11
  12 #ifndef _WX_VECTOR_H_
  13 #define _WX_VECTOR_H_
  14
  15 #include "wx/defs.h"
  16
  17 #if wxUSE_STL
  18
  19 #include <vector>
  20 #define wxVector std::vector
  21
  22 #else // !wxUSE_STL
  23
  24 #include "wx/utils.h"
  25 #include "wx/meta/movable.h"
  26 #include "wx/meta/if.h"
  27
  28 #include "wx/beforestd.h"
  29 #include <new> // for placement new
  30 #include "wx/afterstd.h"
  31
  32 namespace wxPrivate
  33 {
  34
  35 // These templates encapsulate memory operations for use by wxVector; there are
  36 // two implementations, both in generic way for any C++ types and as an
  37 // optimized version for "movable" types that uses realloc() and memmove().
  38
  39 // version for movable types:
  40 template<typename T>
  41 struct wxVectorMemOpsMovable
  42 {
  43     static void Free(T* array)
  44         { free(array); }
  45
  46     static T* Realloc(T* old, size_t newCapacity, size_t WXUNUSED(occupiedSize))
  47         { return (T*)realloc(old, newCapacity * sizeof(T)); }
  48
  49     static void MemmoveBackward(T* dest, T* source, size_t count)
  50         { memmove(dest, source, count * sizeof(T)); }
  51
  52     static void MemmoveForward(T* dest, T* source, size_t count)
  53         { memmove(dest, source, count * sizeof(T)); }
  54 };
  55
  56 // generic version for non-movable types:
  57 template<typename T>
  58 struct wxVectorMemOpsGeneric
  59 {
  60     static void Free(T* array)
  61         { ::operator delete(array); }
  62
  63     static T* Realloc(T* old, size_t newCapacity, size_t occupiedSize)
  64     {
  65         T *mem = (T*)::operator new(newCapacity * sizeof(T));
  66         for ( size_t i = 0; i < occupiedSize; i++ )
  67         {
  68             new(mem + i) T(old[i]);
  69             old[i].~T();
  70         }
  71         ::operator delete(old);
  72         return mem;
  73     }
  74
  75     static void MemmoveBackward(T* dest, T* source, size_t count)
  76     {
  77         wxASSERT( dest < source );
  78         T* destptr = dest;
  79         T* sourceptr = source;
  80         for ( size_t i = count; i > 0; --i, ++destptr, ++sourceptr )
  81         {
  82             new(destptr) T(*sourceptr);
  83             sourceptr->~T();
  84         }
  85     }
  86
  87     static void MemmoveForward(T* dest, T* source, size_t count)
  88     {
  89         wxASSERT( dest > source );
  90         T* destptr = dest + count - 1;
  91         T* sourceptr = source + count - 1;
  92         for ( size_t i = count; i > 0; --i, --destptr, --sourceptr )
  93         {
  94             new(destptr) T(*sourceptr);
  95             sourceptr->~T();
  96         }
  97     }
  98 };
  99
 100
 101 } // namespace wxPrivate
 102
 103 template<typename T>
 104 class wxVector
 105 {
 106 private:
 107     // This cryptic expression means "typedef Ops to wxVectorMemOpsMovable if
 108     // type T is movable type, otherwise to wxVectorMemOpsGeneric".
 109     //
 110     // Note that we use typedef instead of privately deriving from this (which
 111     // would allowed us to omit "Ops::" prefixes below) to keep VC6 happy,
 112     // it can't compile code that derives from wxIf<...>::value.
 113     typedef typename wxIf< wxIsMovable<T>::value,
 114                            wxPrivate::wxVectorMemOpsMovable<T>,
 115                            wxPrivate::wxVectorMemOpsGeneric<T> >::value
 116             Ops;
 117
 118 public:
 119     typedef size_t size_type;
 120     typedef size_t difference_type;
 121     typedef T value_type;
 122     typedef value_type* pointer;
 123     typedef value_type* iterator;
 124     typedef const value_type* const_iterator;
 125     typedef value_type& reference;
 126
 127     class reverse_iterator
 128     {
 129     public:
 130         reverse_iterator() : m_ptr(NULL) { }
 131         wxEXPLICIT reverse_iterator(iterator it) : m_ptr(it) { }
 132         reverse_iterator(const reverse_iterator& it) : m_ptr(it.m_ptr) { }
 133
 134         reference operator*() const { return *m_ptr; }
 135         pointer operator->() const { return m_ptr; }
 136
 137         iterator base() const { return m_ptr; }
 138
 139         reverse_iterator& operator++()
 140                 { --m_ptr; return *this; }
 141         reverse_iterator operator++(int)
 142                 { reverse_iterator tmp = *this; --m_ptr; return tmp; }
 143         reverse_iterator& operator--()
 144                 { ++m_ptr; return *this; }
 145         reverse_iterator operator--(int)
 146                 { reverse_iterator tmp = *this; ++m_ptr; return tmp; }
 147
 148         reverse_iterator operator+(difference_type n) const
 149                 { return reverse_iterator(m_ptr - n); }
 150         reverse_iterator& operator+=(difference_type n)
 151                 { return m_ptr -= n; return *this; }
 152         reverse_iterator operator-(difference_type n) const
 153                 { return reverse_iterator(m_ptr + n); }
 154         reverse_iterator& operator-=(difference_type n)
 155                 { return m_ptr += n; return *this; }
 156
 157         reference operator[](difference_type n) const
 158                 { return *(*this + n); }
 159
 160         bool operator ==(const reverse_iterator& it) const
 161                 { return m_ptr == it.m_ptr; }
 162         bool operator !=(const reverse_iterator& it) const
 163                 { return m_ptr != it.m_ptr; }
 164
 165     private:
 166         value_type *m_ptr;
 167     };
 168
 169     wxVector() : m_size(0), m_capacity(0), m_values(NULL) {}
 170
 171     wxVector(const wxVector& c) : m_size(0), m_capacity(0), m_values(NULL)
 172     {
 173         Copy(c);
 174     }
 175
 176     ~wxVector()
 177     {
 178         clear();
 179     }
 180
 181     void clear()
 182     {
 183         // call destructors of stored objects:
 184         for ( size_type i = 0; i < m_size; i++ )
 185         {
 186             m_values[i].~T();
 187         }
 188
 189         Ops::Free(m_values);
 190         m_values = NULL;
 191         m_size =
 192         m_capacity = 0;
 193     }
 194
 195     void reserve(size_type n)
 196     {
 197         if ( n <= m_capacity )
 198             return;
 199
 200         // increase the size twice, unless we're already too big or unless
 201         // more is requested
 202         //
 203         // NB: casts to size_type are needed to suppress mingw32 warnings about
 204         //     mixing enums and ints in the same expression
 205         const size_type increment = m_size > 0
 206                                      ? wxMin(m_size, (size_type)ALLOC_MAX_SIZE)
 207                                      : (size_type)ALLOC_INITIAL_SIZE;
 208         if ( m_capacity + increment > n )
 209             n = m_capacity + increment;
 210
 211         m_values = Ops::Realloc(m_values, n * sizeof(value_type), m_size);
 212         m_capacity = n;
 213     }
 214
 215     size_type size() const
 216     {
 217         return m_size;
 218     }
 219
 220     size_type capacity() const
 221     {
 222         return m_capacity;
 223     }
 224
 225     bool empty() const
 226     {
 227         return size() == 0;
 228     }
 229
 230     wxVector& operator=(const wxVector& vb)
 231     {
 232         clear();
 233         Copy(vb);
 234         return *this;
 235     }
 236
 237     void push_back(const value_type& v)
 238     {
 239         reserve(size() + 1);
 240
 241         // use placement new to initialize new object in preallocated place in
 242         // m_values and store 'v' in it:
 243         void* const place = m_values + m_size;
 244         new(place) value_type(v);
 245
 246         // only increase m_size if the ctor didn't throw an exception; notice
 247         // that if it _did_ throw, everything is OK, because we only increased
 248         // vector's capacity so far and possibly written some data to
 249         // uninitialized memory at the end of m_values
 250         m_size++;
 251     }
 252
 253     void pop_back()
 254     {
 255         erase(end() - 1);
 256     }
 257
 258     const value_type& at(size_type idx) const
 259     {
 260         wxASSERT(idx < m_size);
 261         return m_values[idx];
 262     }
 263
 264     value_type& at(size_type idx)
 265     {
 266         wxASSERT(idx < m_size);
 267         return m_values[idx];
 268     }
 269
 270     const value_type& operator[](size_type idx) const  { return at(idx); }
 271     value_type& operator[](size_type idx) { return at(idx); }
 272     const value_type& front() const { return at(0); }
 273     value_type& front() { return at(0); }
 274     const value_type& back() const { return at(size() - 1); }
 275     value_type& back() { return at(size() - 1); }
 276
 277     const_iterator begin() const { return m_values; }
 278     iterator begin() { return m_values; }
 279     const_iterator end() const { return m_values + size(); }
 280     iterator end() { return m_values + size(); }
 281
 282     reverse_iterator rbegin() { return reverse_iterator(end() - 1); }
 283     reverse_iterator rend() { return reverse_iterator(begin() - 1); }
 284
 285     iterator insert(iterator it, const value_type& v = value_type())
 286     {
 287         // NB: this must be done before reserve(), because reserve()
 288         //     invalidates iterators!
 289         const size_t idx = it - begin();
 290         const size_t after = end() - it;
 291
 292         reserve(size() + 1);
 293
 294         // unless we're inserting at the end, move following elements out of
 295         // the way:
 296         if ( after > 0 )
 297         {
 298             Ops::MemmoveForward(m_values + idx + 1, m_values + idx, after);
 299         }
 300
 301 #if wxUSE_EXCEPTIONS
 302         try
 303         {
 304 #endif
 305             // use placement new to initialize new object in preallocated place
 306             // in m_values and store 'v' in it:
 307             void* const place = m_values + idx;
 308             new(place) value_type(v);
 309 #if wxUSE_EXCEPTIONS
 310         }
 311         catch ( ... )
 312         {
 313             // if the ctor threw an exception, we need to move all the elements
 314             // back to their original positions in m_values
 315             if ( after > 0 )
 316             {
 317                 Ops::MemmoveBackward(m_values + idx, m_values + idx + 1, after);
 318             }
 319
 320             throw; // rethrow the exception
 321         }
 322 #endif // wxUSE_EXCEPTIONS
 323
 324         // increment m_size only if ctor didn't throw -- if it did, we'll be
 325         // left with m_values larger than necessary, but number of elements will
 326         // be the same
 327         m_size++;
 328
 329         return begin() + idx;
 330     }
 331
 332     iterator erase(iterator it)
 333     {
 334         return erase(it, it + 1);
 335     }
 336
 337     iterator erase(iterator first, iterator last)
 338     {
 339         if ( first == last )
 340             return first;
 341         wxASSERT( first < end() && last <= end() );
 342
 343         const size_type idx = first - begin();
 344         const size_type count = last - first;
 345         const size_type after = end() - last;
 346
 347         // erase elements by calling their destructors:
 348         for ( iterator i = first; i < last; ++i )
 349             i->~T();
 350
 351         // once that's done, move following elements over to the freed space:
 352         if ( after > 0 )
 353         {
 354             Ops::MemmoveBackward(m_values + idx, m_values + idx + count, after);
 355         }
 356
 357         m_size -= count;
 358
 359         return begin() + idx;
 360     }
 361
 362 #if WXWIN_COMPATIBILITY_2_8
 363     wxDEPRECATED( size_type erase(size_type n) );
 364 #endif // WXWIN_COMPATIBILITY_2_8
 365
 366 private:
 367     // VC6 can't compile static const int members
 368     enum { ALLOC_INITIAL_SIZE = 16 };
 369     enum { ALLOC_MAX_SIZE = 4096 };
 370
 371     void Copy(const wxVector& vb)
 372     {
 373         reserve(vb.size());
 374
 375         for ( const_iterator i = vb.begin(); i != vb.end(); ++i )
 376             push_back(*i);
 377     }
 378
 379 private:
 380     size_type m_size,
 381               m_capacity;
 382     value_type *m_values;
 383 };
 384
 385 #if WXWIN_COMPATIBILITY_2_8
 386 template<typename T>
 387 inline typename wxVector<T>::size_type wxVector<T>::erase(size_type n)
 388 {
 389     erase(begin() + n);
 390     return n;
 391 }
 392 #endif // WXWIN_COMPATIBILITY_2_8
 393
 394 #endif // wxUSE_STL/!wxUSE_STL
 395
 396 #if WXWIN_COMPATIBILITY_2_8
 397     #define WX_DECLARE_VECTORBASE(obj, cls) typedef wxVector<obj> cls
 398     #define _WX_DECLARE_VECTOR(obj, cls, exp) WX_DECLARE_VECTORBASE(obj, cls)
 399     #define WX_DECLARE_VECTOR(obj, cls) WX_DECLARE_VECTORBASE(obj, cls)
 400 #endif // WXWIN_COMPATIBILITY_2_8
 401
 402 #endif // _WX_VECTOR_H_