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
3 
6 /*
7 -----------------------------------------------------------------------------
8 This source file is part of GIMPACT Library.
9 
10 For the latest info, see http://gimpact.sourceforge.net/
11 
12 Copyright (c) 2006 Francisco Leon Najera. C.C. 80087371.
13 email: 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 #define GIM_ARRAY_GROW_INCREMENT 2
38 #define GIM_ARRAY_GROW_FACTOR 2
39 
41 template <typename T>
42 class gim_array
43 {
44 public:
47  T* m_data;
53 
54  inline void destroyData()
55  {
56  m_allocated_size = 0;
57  if (m_data == NULL) return;
59  m_data = NULL;
60  }
61 
62  inline bool resizeData(GUINT newsize)
63  {
64  if (newsize == 0)
65  {
66  destroyData();
67  return true;
68  }
69 
70  if (m_size > 0)
71  {
72  m_data = (T*)gim_realloc(m_data, m_size * sizeof(T), newsize * sizeof(T));
73  }
74  else
75  {
76  m_data = (T*)gim_alloc(newsize * sizeof(T));
77  }
78  m_allocated_size = newsize;
79  return true;
80  }
81 
82  inline bool growingCheck()
83  {
84  if (m_allocated_size <= m_size)
85  {
86  GUINT requestsize = m_size;
88  if (resizeData((requestsize + GIM_ARRAY_GROW_INCREMENT) * GIM_ARRAY_GROW_FACTOR) == false) return false;
89  }
90  return true;
91  }
92 
96  inline bool reserve(GUINT size)
97  {
98  if (m_allocated_size >= size) return false;
99  return resizeData(size);
100  }
101 
102  inline void clear_range(GUINT start_range)
103  {
104  while (m_size > start_range)
105  {
106  m_data[--m_size].~T();
107  }
108  }
109 
110  inline void clear()
111  {
112  if (m_size == 0) return;
113  clear_range(0);
114  }
115 
116  inline void clear_memory()
117  {
118  clear();
119  destroyData();
120  }
121 
123  {
124  m_data = 0;
125  m_size = 0;
126  m_allocated_size = 0;
127  }
128 
129  gim_array(GUINT reservesize)
130  {
131  m_data = 0;
132  m_size = 0;
133 
134  m_allocated_size = 0;
135  reserve(reservesize);
136  }
137 
139  {
140  clear_memory();
141  }
142 
143  inline GUINT size() const
144  {
145  return m_size;
146  }
147 
148  inline GUINT max_size() const
149  {
150  return m_allocated_size;
151  }
152 
153  inline T& operator[](size_t i)
154  {
155  return m_data[i];
156  }
157  inline const T& operator[](size_t i) const
158  {
159  return m_data[i];
160  }
161 
162  inline T* pointer() { return m_data; }
163  inline const T* pointer() const
164  {
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  inline void swap(GUINT i, GUINT j)
209  {
210  gim_swap_elements(m_data, i, j);
211  }
212 
213  inline void push_back(const T& obj)
214  {
215  this->growingCheck();
216  m_data[m_size] = obj;
217  m_size++;
218  }
219 
221  inline void push_back_mem()
222  {
223  this->growingCheck();
224  m_size++;
225  }
226 
227  inline void push_back_memcpy(const T& obj)
228  {
229  this->growingCheck();
230  gim_simd_memcpy(&m_data[m_size], &obj, sizeof(T));
231  m_size++;
232  }
233 
234  inline void pop_back()
235  {
236  m_size--;
237  m_data[m_size].~T();
238  }
239 
241  inline void pop_back_mem()
242  {
243  m_size--;
244  }
245 
247  inline void erase(GUINT index)
248  {
249  if (index < m_size - 1)
250  {
251  swap(index, m_size - 1);
252  }
253  pop_back();
254  }
255 
256  inline void erase_sorted_mem(GUINT index)
257  {
258  m_size--;
259  for (GUINT i = index; i < m_size; i++)
260  {
261  gim_simd_memcpy(m_data + i, m_data + i + 1, sizeof(T));
262  }
263  }
264 
265  inline void erase_sorted(GUINT index)
266  {
267  m_data[index].~T();
268  erase_sorted_mem(index);
269  }
270 
271  inline void insert_mem(GUINT index)
272  {
273  this->growingCheck();
274  for (GUINT i = m_size; i > index; i--)
275  {
276  gim_simd_memcpy(m_data + i, m_data + i - 1, sizeof(T));
277  }
278  m_size++;
279  }
280 
281  inline void insert(const T& obj, GUINT index)
282  {
283  insert_mem(index);
284  m_data[index] = obj;
285  }
286 
287  inline void resize(GUINT size, bool call_constructor = true, const T& fillData = T())
288  {
289  if (size > m_size)
290  {
291  reserve(size);
292  if (call_constructor)
293  {
294  while (m_size < size)
295  {
296  m_data[m_size] = fillData;
297  m_size++;
298  }
299  }
300  else
301  {
302  m_size = size;
303  }
304  }
305  else if (size < m_size)
306  {
307  if (call_constructor) clear_range(size);
308  m_size = size;
309  }
310  }
311 
312  inline void refit()
313  {
315  }
316 };
317 
318 #endif // GIM_CONTAINERS_H_INCLUDED
gim_array::insert_mem
void insert_mem(GUINT index)
Definition: gim_array.h:271
gim_array::m_data
T * m_data
properties
Definition: gim_array.h:47
gim_array::swap
void swap(GUINT i, GUINT j)
Definition: gim_array.h:208
gim_array::erase_sorted_mem
void erase_sorted_mem(GUINT index)
Definition: gim_array.h:256
gim_array::gim_array
gim_array(GUINT reservesize)
Definition: gim_array.h:129
gim_array::get_pointer_at
const T * get_pointer_at(GUINT i) const
Definition: gim_array.h:173
gim_array::refit
void refit()
Definition: gim_array.h:312
gim_array::at
T & at(GUINT i)
Definition: gim_array.h:178
gim_array
Very simple array container with fast access and simd memory.
Definition: gim_array.h:42
GIM_ARRAY_GROW_FACTOR
#define GIM_ARRAY_GROW_FACTOR
Definition: gim_array.h:38
gim_array::pointer
const T * pointer() const
Definition: gim_array.h:163
gim_array::destroyData
void destroyData()
protected operations
Definition: gim_array.h:54
gim_array::m_allocated_size
GUINT m_allocated_size
Definition: gim_array.h:49
gim_array::operator[]
const T & operator[](size_t i) const
Definition: gim_array.h:157
gim_array::pop_back_mem
void pop_back_mem()
Simply decrease the m_size, doesn't call the deleted element destructor.
Definition: gim_array.h:241
gim_array::reserve
bool reserve(GUINT size)
public operations
Definition: gim_array.h:96
GUINT
#define GUINT
Definition: gim_math.h:40
gim_free
void gim_free(void *ptr)
Definition: gim_memory.cpp:117
GIM_ARRAY_GROW_INCREMENT
#define GIM_ARRAY_GROW_INCREMENT
Definition: gim_array.h:37
gim_array::growingCheck
bool growingCheck()
Definition: gim_array.h:82
gim_array::gim_array
gim_array()
Definition: gim_array.h:122
gim_array::push_back_memcpy
void push_back_memcpy(const T &obj)
Definition: gim_array.h:227
gim_array::get_pointer_at
T * get_pointer_at(GUINT i)
Definition: gim_array.h:168
gim_array::clear_memory
void clear_memory()
Definition: gim_array.h:116
gim_array::operator[]
T & operator[](size_t i)
Definition: gim_array.h:153
gim_memory.h
gim_array::back
T & back()
Definition: gim_array.h:198
gim_array::max_size
GUINT max_size() const
Definition: gim_array.h:148
gim_array::insert
void insert(const T &obj, GUINT index)
Definition: gim_array.h:281
gim_array::erase
void erase(GUINT index)
fast erase
Definition: gim_array.h:247
gim_array::pop_back
void pop_back()
Definition: gim_array.h:234
gim_array::push_back
void push_back(const T &obj)
Definition: gim_array.h:213
gim_array::push_back_mem
void push_back_mem()
Simply increase the m_size, doesn't call the new element constructor.
Definition: gim_array.h:221
gim_array::front
T & front()
Definition: gim_array.h:188
gim_realloc
void * gim_realloc(void *ptr, size_t oldsize, size_t newsize)
Definition: gim_memory.cpp:108
gim_swap_elements
void gim_swap_elements(T *_array, size_t _i, size_t _j)
Definition: gim_memory.h:150
gim_array::m_size
GUINT m_size
Definition: gim_array.h:48
gim_array::clear
void clear()
Definition: gim_array.h:110
gim_array::pointer
T * pointer()
Definition: gim_array.h:162
gim_simd_memcpy
void gim_simd_memcpy(void *dst, const void *src, size_t copysize)
Definition: gim_memory.h:120
gim_array::erase_sorted
void erase_sorted(GUINT index)
Definition: gim_array.h:265
gim_array::~gim_array
~gim_array()
Definition: gim_array.h:138
gim_alloc
void * gim_alloc(size_t size)
Standar Memory functions.
Definition: gim_memory.cpp:82
gim_array::resize
void resize(GUINT size, bool call_constructor=true, const T &fillData=T())
Definition: gim_array.h:287
gim_array::front
const T & front() const
Definition: gim_array.h:193
gim_array::at
const T & at(GUINT i) const
Definition: gim_array.h:183
gim_array::back
const T & back() const
Definition: gim_array.h:203
gim_array::resizeData
bool resizeData(GUINT newsize)
Definition: gim_array.h:62
gim_array::size
GUINT size() const
Definition: gim_array.h:143
gim_array::clear_range
void clear_range(GUINT start_range)
Definition: gim_array.h:102