Bullet Collision Detection & Physics Library
gim_array.h
Go to the documentation of this file.
1#ifndef GIM_ARRAY_H_INCLUDED
2#define GIM_ARRAY_H_INCLUDED
6/*
7-----------------------------------------------------------------------------
8This source file is part of GIMPACT Library.
9
10For the latest info, see http://gimpact.sourceforge.net/
11
12Copyright (c) 2006 Francisco Leon Najera. C.C. 80087371.
13email: projectileman@yahoo.com
14
15 This library is free software; you can redistribute it and/or
16 modify it under the terms of EITHER:
17 (1) The GNU Lesser General Public License as published by the Free
18 Software Foundation; either version 2.1 of the License, or (at
19 your option) any later version. The text of the GNU Lesser
20 General Public License is included with this library in the
21 file GIMPACT-LICENSE-LGPL.TXT.
22 (2) The BSD-style license that is included with this library in
23 the file GIMPACT-LICENSE-BSD.TXT.
24 (3) The zlib/libpng license that is included with this library in
25 the file GIMPACT-LICENSE-ZLIB.TXT.
26
27 This library is distributed in the hope that it will be useful,
28 but WITHOUT ANY WARRANTY; without even the implied warranty of
29 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the files
30 GIMPACT-LICENSE-LGPL.TXT, GIMPACT-LICENSE-ZLIB.TXT and GIMPACT-LICENSE-BSD.TXT for more details.
31
32-----------------------------------------------------------------------------
33*/
34
35#include "gim_memory.h"
36
37
38#define GIM_ARRAY_GROW_INCREMENT 2
39#define GIM_ARRAY_GROW_FACTOR 2
40
42template<typename T>
44{
45public:
54
55 inline void destroyData()
56 {
58 if(m_data==NULL) return;
60 m_data = NULL;
61 }
62
63 inline bool resizeData(GUINT newsize)
64 {
65 if(newsize==0)
66 {
68 return true;
69 }
70
71 if(m_size>0)
72 {
73 m_data = (T*)gim_realloc(m_data,m_size*sizeof(T),newsize*sizeof(T));
74 }
75 else
76 {
77 m_data = (T*)gim_alloc(newsize*sizeof(T));
78 }
79 m_allocated_size = newsize;
80 return true;
81 }
82
83 inline bool growingCheck()
84 {
86 {
87 GUINT requestsize = m_size;
89 if(resizeData((requestsize+GIM_ARRAY_GROW_INCREMENT)*GIM_ARRAY_GROW_FACTOR)==false) return false;
90 }
91 return true;
92 }
93
97 inline bool reserve(GUINT size)
98 {
99 if(m_allocated_size>=size) return false;
100 return resizeData(size);
101 }
102
103 inline void clear_range(GUINT start_range)
104 {
105 while(m_size>start_range)
106 {
107 m_data[--m_size].~T();
108 }
109 }
110
111 inline void clear()
112 {
113 if(m_size==0)return;
114 clear_range(0);
115 }
116
117 inline void clear_memory()
118 {
119 clear();
120 destroyData();
121 }
122
124 {
125 m_data = 0;
126 m_size = 0;
128 }
129
130 gim_array(GUINT reservesize)
131 {
132 m_data = 0;
133 m_size = 0;
134
136 reserve(reservesize);
137 }
138
140 {
141 clear_memory();
142 }
143
144 inline GUINT size() const
145 {
146 return m_size;
147 }
148
149 inline GUINT max_size() const
150 {
151 return m_allocated_size;
152 }
153
154 inline T & operator[](size_t i)
155 {
156 return m_data[i];
157 }
158 inline const T & operator[](size_t i) const
159 {
160 return m_data[i];
161 }
162
163 inline T * pointer(){ return m_data;}
164 inline const T * pointer() const
165 { return m_data;}
166
167
168 inline T * get_pointer_at(GUINT i)
169 {
170 return m_data + i;
171 }
172
173 inline const T * get_pointer_at(GUINT i) const
174 {
175 return m_data + i;
176 }
177
178 inline T & at(GUINT i)
179 {
180 return m_data[i];
181 }
182
183 inline const T & at(GUINT i) const
184 {
185 return m_data[i];
186 }
187
188 inline T & front()
189 {
190 return *m_data;
191 }
192
193 inline const T & front() const
194 {
195 return *m_data;
196 }
197
198 inline T & back()
199 {
200 return m_data[m_size-1];
201 }
202
203 inline const T & back() const
204 {
205 return m_data[m_size-1];
206 }
207
208
209 inline void swap(GUINT i, GUINT j)
210 {
212 }
213
214 inline void push_back(const T & obj)
215 {
216 this->growingCheck();
217 m_data[m_size] = obj;
218 m_size++;
219 }
220
222 inline void push_back_mem()
223 {
224 this->growingCheck();
225 m_size++;
226 }
227
228 inline void push_back_memcpy(const T & obj)
229 {
230 this->growingCheck();
231 gim_simd_memcpy(&m_data[m_size],&obj,sizeof(T));
232 m_size++;
233 }
234
235 inline void pop_back()
236 {
237 m_size--;
238 m_data[m_size].~T();
239 }
240
242 inline void pop_back_mem()
243 {
244 m_size--;
245 }
246
248 inline void erase(GUINT index)
249 {
250 if(index<m_size-1)
251 {
252 swap(index,m_size-1);
253 }
254 pop_back();
255 }
256
257 inline void erase_sorted_mem(GUINT index)
258 {
259 m_size--;
260 for(GUINT i = index;i<m_size;i++)
261 {
262 gim_simd_memcpy(m_data+i,m_data+i+1,sizeof(T));
263 }
264 }
265
266 inline void erase_sorted(GUINT index)
267 {
268 m_data[index].~T();
269 erase_sorted_mem(index);
270 }
271
272 inline void insert_mem(GUINT index)
273 {
274 this->growingCheck();
275 for(GUINT i = m_size;i>index;i--)
276 {
277 gim_simd_memcpy(m_data+i,m_data+i-1,sizeof(T));
278 }
279 m_size++;
280 }
281
282 inline void insert(const T & obj,GUINT index)
283 {
284 insert_mem(index);
285 m_data[index] = obj;
286 }
287
288 inline void resize(GUINT size, bool call_constructor = true, const T& fillData=T())
289 {
290 if(size>m_size)
291 {
292 reserve(size);
293 if(call_constructor)
294 {
295 while(m_size<size)
296 {
297 m_data[m_size] = fillData;
298 m_size++;
299 }
300 }
301 else
302 {
303 m_size = size;
304 }
305 }
306 else if(size<m_size)
307 {
308 if(call_constructor) clear_range(size);
309 m_size = size;
310 }
311 }
312
313 inline void refit()
314 {
316 }
317
318};
319
320
321
322
323
324#endif // GIM_CONTAINERS_H_INCLUDED
Very simple array container with fast access and simd memory.
Definition: gim_array.h:44
void erase(GUINT index)
fast erase
Definition: gim_array.h:248
T & operator[](size_t i)
Definition: gim_array.h:154
T & at(GUINT i)
Definition: gim_array.h:178
const T * pointer() const
Definition: gim_array.h:164
GUINT m_size
Definition: gim_array.h:49
const T & operator[](size_t i) const
Definition: gim_array.h:158
const T & front() const
Definition: gim_array.h:193
T & back()
Definition: gim_array.h:198
gim_array(GUINT reservesize)
Definition: gim_array.h:130
T * get_pointer_at(GUINT i)
Definition: gim_array.h:168
void push_back(const T &obj)
Definition: gim_array.h:214
bool reserve(GUINT size)
public operations
Definition: gim_array.h:97
~gim_array()
Definition: gim_array.h:139
const T * get_pointer_at(GUINT i) const
Definition: gim_array.h:173
const T & at(GUINT i) const
Definition: gim_array.h:183
GUINT size() const
Definition: gim_array.h:144
void erase_sorted_mem(GUINT index)
Definition: gim_array.h:257
GUINT max_size() const
Definition: gim_array.h:149
void push_back_memcpy(const T &obj)
Definition: gim_array.h:228
void erase_sorted(GUINT index)
Definition: gim_array.h:266
void swap(GUINT i, GUINT j)
Definition: gim_array.h:209
bool resizeData(GUINT newsize)
Definition: gim_array.h:63
void pop_back_mem()
Simply decrease the m_size, doesn't call the deleted element destructor.
Definition: gim_array.h:242
void insert(const T &obj, GUINT index)
Definition: gim_array.h:282
void resize(GUINT size, bool call_constructor=true, const T &fillData=T())
Definition: gim_array.h:288
void destroyData()
protected operations
Definition: gim_array.h:55
bool growingCheck()
Definition: gim_array.h:83
void clear()
Definition: gim_array.h:111
void clear_range(GUINT start_range)
Definition: gim_array.h:103
T * m_data
properties
Definition: gim_array.h:48
GUINT m_allocated_size
Definition: gim_array.h:50
T & front()
Definition: gim_array.h:188
void push_back_mem()
Simply increase the m_size, doesn't call the new element constructor.
Definition: gim_array.h:222
void insert_mem(GUINT index)
Definition: gim_array.h:272
void refit()
Definition: gim_array.h:313
const T & back() const
Definition: gim_array.h:203
T * pointer()
Definition: gim_array.h:163
void pop_back()
Definition: gim_array.h:235
void clear_memory()
Definition: gim_array.h:117
#define GIM_ARRAY_GROW_INCREMENT
Definition: gim_array.h:38
#define GIM_ARRAY_GROW_FACTOR
Definition: gim_array.h:39
#define GUINT
Definition: gim_math.h:42
void * gim_alloc(size_t size)
Standar Memory functions.
Definition: gim_memory.cpp:86
void * gim_realloc(void *ptr, size_t oldsize, size_t newsize)
Definition: gim_memory.cpp:110
void gim_free(void *ptr)
Definition: gim_memory.cpp:119
void gim_simd_memcpy(void *dst, const void *src, size_t copysize)
Definition: gim_memory.h:130
void gim_swap_elements(T *_array, size_t _i, size_t _j)
Definition: gim_memory.h:162