libs/container/array.h

   1 /*
   2    Copyright (C) 2001-2006, William Joseph.
   3    All Rights Reserved.
   4
   5    This file is part of GtkRadiant.
   6
   7    GtkRadiant is free software; you can redistribute it and/or modify
   8    it under the terms of the GNU General Public License as published by
   9    the Free Software Foundation; either version 2 of the License, or
  10    (at your option) any later version.
  11
  12    GtkRadiant is distributed in the hope that it will be useful,
  13    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15    GNU General Public License for more details.
  16
  17    You should have received a copy of the GNU General Public License
  18    along with GtkRadiant; if not, write to the Free Software
  19    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
  20  */
  21
  22 #if !defined( INCLUDED_CONTAINER_ARRAY_H )
  23 #define INCLUDED_CONTAINER_ARRAY_H
  24
  25 #include "globaldefs.h"
  26 #include <cstddef>
  27 #include <algorithm>
  28
  29 #include "memory/allocator.h"
  30
  31 /// \brief An array whose size is variable at run-time.
  32 ///
  33 /// - Resizing the array destroys all the existing elements and invalidates all iterators.
  34 /// - Default-Constructible, Copyable, Assignable.
  35 /// - Compatible with the containers and algorithms in the Standard Template Library (STL) - http://www.sgi.com/tech/stl/
  36 ///
  37 /// \param Element The type to be stored in the array. Must provide a default-constructor and a copy-constructor.
  38 /// \param Allocator A custom memory-allocator, conforming to the std::allocator interface.
  39 template<typename Element, typename Allocator = DefaultAllocator<Element> >
  40 class Array : public Allocator
  41 {
  42 std::size_t m_size;
  43 Element* m_data;
  44
  45 Element* construct( std::size_t size ){
  46 #if 1
  47         return New<Element, Allocator>( *this ).vector( size );
  48 #else
  49         return new Element[size];
  50 #endif
  51 }
  52 template<typename T1>
  53 Element* construct( std::size_t size, const T1& value ){
  54         return New<Element, Allocator>( *this ).vector( size, value );
  55 }
  56 void destroy( Element* data, std::size_t size ){
  57 #if 1
  58         Delete<Element, Allocator>( *this ).vector( data, size );
  59 #else
  60         delete[] data;
  61 #endif
  62 }
  63
  64 public:
  65 typedef Element value_type;
  66 typedef value_type* iterator;
  67 typedef const value_type* const_iterator;
  68
  69 Array()
  70         : m_size( 0 ), m_data( 0 ){
  71 }
  72 Array( std::size_t size )
  73         : m_size( size ), m_data( construct( size ) ){
  74 }
  75 template<typename T1>
  76 Array( std::size_t size, const T1& value )
  77         : m_size( size ), m_data( construct( size, value ) ){
  78 }
  79 Array( const Array& other )
  80         : Allocator( other ), m_size( other.size() ), m_data( construct( m_size ) ){
  81         std::copy( other.begin(), other.end(), begin() );
  82 }
  83 template<typename Iterator>
  84 Array( Iterator start, Iterator finish )
  85         : m_size( std::distance( start, finish ) ), m_data( construct( m_size ) ){
  86         std::copy( start, finish, begin() );
  87 }
  88 ~Array(){
  89         destroy( m_data, m_size );
  90 }
  91
  92 Array& operator=( const Array& other ){
  93         if ( other.size() == size() ) {
  94                 std::copy( other.begin(), other.end(), begin() );
  95         }
  96         else
  97         {
  98                 Array temp( other );
  99                 temp.swap( *this );
 100         }
 101         return *this;
 102 }
 103
 104 void swap( Array& other ){
 105         std::swap( m_size, other.m_size );
 106         std::swap( m_data, other.m_data );
 107 }
 108
 109 iterator begin(){
 110         return m_data;
 111 }
 112 const_iterator begin() const {
 113         return m_data;
 114 }
 115 iterator end(){
 116         return m_data + m_size;
 117 }
 118 const_iterator end() const {
 119         return m_data + m_size;
 120 }
 121
 122 value_type& operator[]( std::size_t index ){
 123 #if GDEF_DEBUG
 124         ASSERT_MESSAGE( index < size(), "array index out of bounds" );
 125 #endif
 126         return m_data[index];
 127 }
 128 const value_type& operator[]( std::size_t index ) const {
 129 #if GDEF_DEBUG
 130         ASSERT_MESSAGE( index < size(), "array index out of bounds" );
 131 #endif
 132         return m_data[index];
 133 }
 134 value_type* data(){
 135         return m_data;
 136 }
 137 const value_type* data() const {
 138         return m_data;
 139 }
 140 std::size_t size() const {
 141         return m_size;
 142 }
 143 bool empty() const {
 144         return m_size == 0;
 145 }
 146
 147 void resize( std::size_t count ){
 148         if ( count != size() ) {
 149                 Array temp( count );
 150                 temp.swap( *this );
 151         }
 152 }
 153 void resize( std::size_t count, const value_type& value ){
 154         if ( count != size() ) {
 155                 Array temp( count, value );
 156                 temp.swap( *this );
 157         }
 158 }
 159 };
 160
 161 namespace std
 162 {
 163 /// \brief Swaps the values of \p self and \p other.
 164 /// Overloads std::swap.
 165 template<typename Element, typename Allocator>
 166 inline void swap( Array<Element, Allocator>& self, Array<Element, Allocator>& other ){
 167         self.swap( other );
 168 }
 169 }
 170 #endif