AGX Dynamics 2.40.0.0
Loading...
Searching...
No Matches
agx/StackArray.h
Go to the documentation of this file.
1/*
2Copyright 2007-2025. Algoryx Simulation AB.
3
4All AGX source code, intellectual property, documentation, sample code,
5tutorials, scene files and technical white papers, are copyrighted, proprietary
6and confidential material of Algoryx Simulation AB. You may not download, read,
7store, distribute, publish, copy or otherwise disseminate, use or expose this
8material unless having a written signed agreement with Algoryx Simulation AB, or having been
9advised so by Algoryx Simulation AB for a time limited evaluation, or having purchased a
10valid commercial license from Algoryx Simulation AB.
11
12Algoryx Simulation AB disclaims all responsibilities for loss or damage caused
13from using this software, unless otherwise stated in written agreements with
14Algoryx Simulation AB.
15*/
16
17#ifndef AGX_STACKARRAY_H
18#define AGX_STACKARRAY_H
19
20#include <agx/agx.h>
21#include <agx/debug.h>
22#include <array>
23#include <cstring>
24#include <initializer_list>
25#include <ostream>
26
27namespace agx
28{
32 template <typename T, size_t N >
34 {
35
36 public:
38
39 StackArray(size_t size, const T& defaultValue = T());
40
41 StackArray(std::initializer_list<T> values);
42
46 size_t size() const;
47
49 bool empty() const;
50
51 T& operator[] (size_t i);
52
53 const T& operator[] (size_t i) const;
54
55 T& at(size_t i);
56
57 const T& at(size_t i) const;
58
59 void push_back(const T& value);
60
61 /*
62 Removes top element. Does not call destructor for this element.
63 Should not be used if size()==0.
64 */
65 void pop_back();
66
67 /*
68 Copy constructor with type conversion.
69 \param rhs: Another StackArray of same type T and with capacity N2 <= N.
70 \retval: A reference to the constructed StackArray.
71 */
72 template <size_t N2>
74
75 /*
76 Removes all elements. Does not call destructor for these elements.
77 */
78 void clear();
79
80 T& back();
81
82 const T& back() const;
83
84 T& front();
85
86 const T& front() const;
87
88 T* begin() noexcept;
89 const T* begin() const noexcept;
90
91 T* end() noexcept;
92 const T* end() const noexcept;
93
94 void erase(size_t index);
95
96 private:
97 template <typename T2, size_t N2>
98 friend std::ostream& operator << ( std::ostream& output, const StackArray<T2, N2>& array);
99
100
101 private:
102 std::array<T, N> m_elements;
103 size_t m_size;
104 };
105
106 template <typename T, size_t N>
107 T* begin(StackArray<T, N>& array);
108
109 template <typename T, size_t N>
110 const T* begin(const StackArray<T, N>& array);
111
112 template <typename T, size_t N>
113 T* end(StackArray<T, N>& array);
114
115 template <typename T, size_t N>
116 const T* end(const StackArray<T, N>& array);
117
119 template <typename T, size_t N>
120 AGX_FORCE_INLINE StackArray<T, N>::StackArray() : m_elements(), m_size(0)
121 {
122 m_elements.fill( T() );
123 }
124
125 template <typename T, size_t N>
126 template <size_t N2>
128 {
129 agxAssert(rhs.size() <= N);
130 m_size = rhs.size();
131 for (size_t i = 0; i < m_size; ++i)
132 m_elements[i] = rhs[i];
133 return *this;
134 }
135
136
137 template <typename T, size_t N>
138 AGX_FORCE_INLINE StackArray<T, N>::StackArray(size_t size, const T& defaultValue /*= T()*/) : m_size(size)
139 {
140 m_elements.fill( T() );
141 agxAssert(m_size <= N);
142 for (size_t i = 0; i < size; ++i)
143 m_elements[i] = defaultValue;
144 }
145
146
147 template <typename T, size_t N>
148 inline StackArray<T, N>::StackArray(std::initializer_list<T> values)
149 {
150 agxAssert(values.size() <= N);
151 std::copy(std::begin(values), std::end(values), std::begin(m_elements));
152 m_size = values.size();
153 }
154
155
156 template <typename T, size_t N>
158 {
159 return m_size;
160 }
161
162
163 template <typename T, size_t N>
165 {
166 return m_size == 0;
167 }
168
169
170 template <typename T, size_t N>
172 {
173 agxAssert(i < m_size);
174 return m_elements[i];
175 }
176
177
178 template <typename T, size_t N>
180 {
181 agxAssert(i < m_size);
182 return m_elements[i];
183 }
184
185
186 template <typename T, size_t N>
188 {
189 agxAssert(i < m_size);
190 return m_elements[i];
191 }
192
193
194 template <typename T, size_t N>
195 AGX_FORCE_INLINE const T& StackArray<T, N>::at(size_t i) const
196 {
197 agxAssert(i < m_size);
198 return m_elements[i];
199 }
200
201 template <typename T, size_t N>
203 {
204 agxAssert(m_size < N);
205 m_elements[m_size++] = value;
206 }
207
208
209 template <typename T, size_t N>
211 {
212 agxAssert(m_size > 0);
213 m_size--;
214 }
215
216
217 template <typename T, size_t N>
219 {
220 m_size = 0;
221 }
222
223
224 template <typename T, size_t N>
226 {
227 agxAssert(m_size > 0);
228 return m_elements[m_size - 1];
229 }
230
231
232 template <typename T, size_t N>
234 {
235 agxAssert(m_size > 0);
236 return m_elements[m_size - 1];
237 }
238
239
240 template <typename T, size_t N>
242 {
243 agxAssert(m_size > 0);
244 return m_elements[0];
245 }
246
247
248 template <typename T, size_t N>
250 {
251 agxAssert(m_size > 0);
252 return m_elements[0];
253 }
254
255
256 template <typename T, size_t N>
258 {
259 return &m_elements[0];
260 }
261
262 template <typename T, size_t N>
263 const T* StackArray<T, N>::begin() const noexcept
264 {
265 return &m_elements[0];
266 }
267
268 template <typename T, size_t N>
270 {
271 return begin() + size();
272 }
273
274 template <typename T, size_t N>
275 const T* StackArray<T, N>::end() const noexcept
276 {
277 return begin() + size();
278 }
279
280 template <typename T, size_t N>
281 AGX_FORCE_INLINE std::ostream& operator << ( std::ostream& output, const StackArray<T, N>& array)
282 {
283 for (size_t i = 0; i < array.size(); i++) {
284 output << array[i];
285 if (i < array.size()-1)
286 output << ", ";
287 }
288 return output;
289 }
290
291
292 template <typename T, size_t N>
294 {
295 agxAssert( index < m_size);
296 for (size_t i = index + 1; i < m_size; i++)
297 m_elements[i-1] = m_elements[i];
298
299 m_size--;
300 }
301
302
303 template <typename T, size_t N>
305 {
306 return array.begin();
307 }
308
309 template <typename T, size_t N>
310 const T* begin(const StackArray<T, N>& array)
311 {
312 return array.begin();
313 }
314
315 template <typename T, size_t N>
317 {
318 return array.end();
319 }
320
321 template <typename T, size_t N>
322 const T* end(const StackArray<T, N>& array)
323 {
324 return array.end();
325 }
326
327}
328
329
330
331
332#endif /* AGX_STACKARRAY_H */
#define m_size
Definition: agx/Vector.h:429
#define m_elements
Definition: agx/Vector.h:428
Templated stack array class.
size_t size() const
Get the size of the array (number of filled slots).
T * begin() noexcept
T & operator[](size_t i)
T * end() noexcept
const T & at(size_t i) const
void erase(size_t index)
StackArray(size_t size, const T &defaultValue=T())
const T & front() const
bool empty() const
Is the StackArray empty?
const T & back() const
void push_back(const T &value)
StackArray()
Implementations.
StackArray< T, N > & operator=(const StackArray< T, N2 > &rhs)
T & at(size_t i)
StackArray(std::initializer_list< T > values)
#define agxAssert(expr)
Definition: debug.h:143
#define AGX_FORCE_INLINE
Definition: macros.h:58
The agx namespace contains the dynamics/math part of the AGX Dynamics API.
LinearProbingHashSetImplementation< KeyT, HashT >::iterator end(LinearProbingHashSetImplementation< KeyT, HashT > &set)
std::ostream & operator<<(std::ostream &os, const agx::AddedMassInteraction::Matrix6x6 &m)
LinearProbingHashSetImplementation< KeyT, HashT >::iterator begin(LinearProbingHashSetImplementation< KeyT, HashT > &set)
STL namespace.