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