]> git.xonotic.org Git - xonotic/netradiant.git/blob - libs/container/array.h
Merge commit '020d0244e4239b21dc804d630edff926386ea34f' into master-merge
[xonotic/netradiant.git] / 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