3ds Max C++ API Reference
All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Properties Friends Macros Modules Pages
Array< T > Class Template Reference

A generic array container, with proper support for non-POD types. More...

#include <Array.h>

+ Inheritance diagram for Array< T >:

Public Types

typedef int(__cdecl * CompareFnc) (const void *elem1, const void *elem2)
 Type of function to pass to sort().
 

Public Member Functions

 Array ()
 Initializes an empty array.
 
 Array (size_t initUsedLength, const T &defaultVal=T(), size_t initGrowLength=kDefaultGrowthLength)
 Initializes an array with an initial size.
 
 Array (const Array< T > &src)
 Copy constructor.
 
template<class InputIt >
 Array (InputIt begin, InputIt end)
 Copy constructor.
 
 ~Array ()
 Destructor. Destroys every element stored in the array, and frees the allocated storage.
 
Array< T > & operator= (const Array< T > &src)
 Copy operator.
 
bool operator== (const Array< T > &op) const
 Equality operator.
 
Array< T > & setAt (size_t index, const T &value)
 Sets a copy of value at the given index.
 
Array< T > & setAll (const T &value)
 Sets all the elements of the array to the given value.
 
bool isValidIndex (size_t) const
 Returns whether the given array index is valid for this array.
 
T & operator[] (size_t i)
 Subscript operator.
 
const T & operator[] (size_t i) const
 Subscript operator.
 
const T & at (size_t index) const
 Same as subscript operator.
 
T & at (size_t index)
 Same as subscript operator.
 
T & first ()
 Accesses the first element in the array.
 
const T & first () const
 Accesses the first element in the array.
 
T * begin ()
 Accesses the begin iterator, which is a plain pointer in this case.
 
const T * begin () const
 Accesses the const begin iterator, which is a plain pointer in this case.
 
T & last ()
 Accesses the last element in the array.
 
const T & last () const
 Accesses the first element in the array.
 
T * end ()
 Accesses the end iterator (one past last valid element). Do not dereference.
 
const T * end () const
 Accesses the const end iterator (one past last valid element). Do not dereference.
 
size_t append (const T &value)
 Appends a copy of value to the array.
 
Array< T > & append (const T *values, size_t count)
 Appends one or more element(s) to the array.
 
Array< T > & append (const Array< T > &array)
 Appends the contents of another array to this array.
 
Array< T > & insertAt (size_t index, const T &value)
 Inserts a single value, at a given location, into this array.
 
Array< T > & insertAt (size_t index, const T *values, size_t count)
 Inserts a one or more value(s), at a given location, into this array.
 
Array< T > & removeAt (size_t index)
 Removes a single element from the array.
 
bool remove (const T &value, size_t start=0)
 Searches for a value in the array and, if it is found, removes it from the array.
 
Array< T > & removeFirst ()
 Removes the first element of the array.
 
Array< T > & removeLast ()
 Removes the last element of the array.
 
Array< T > & removeAll ()
 Removes all the elements from the array.
 
Array< T > & removeSubArray (size_t startIndex, size_t endIndex)
 Removes a subset of the array.
 
bool contains (const T &value, size_t start=0) const
 Determines if a value is stored in the array.
 
bool find (const T &value, size_t &foundAt, size_t start=0) const
 Searches for a value in the array.
 
size_t find (const T &value) const
 Searches for a value in the array.
 
size_t findFrom (const T &value, size_t start) const
 Searches for a value in the array, starting at a given index.
 
size_t length () const
 Returns the number of used elements (as opposed to simply allocated/reserved) in the array.
 
bool isEmpty () const
 Returns true if the number of used elements in the array is 0; returns false otherwise.
 
size_t lengthUsed () const
 Returns the number of elements used (as opposed to simply allocated/reserved) in the array.
 
Array< T > & setLengthUsed (size_t length, const T &defaultVal=T())
 Sets the number of elements used (as opposed to simply allocated/reserved) in the array.
 
size_t lengthReserved () const
 Returns the number of elements allocated/reserved (as opposed to actually used) in the array.
 
Array< T > & setLengthReserved (size_t length)
 Sets the number of elements allocated/reserved (as opposed to actually used) in the array.
 
void reserve (size_t capacity)
 Alias for setLengthReserved.
 
size_t growLength () const
 Returns the growth length of the array.
 
Array< T > & setGrowLength (size_t)
 Sets the growth length of the array.
 
Array< T > & reverse ()
 Reverses the sequence of elements in the array.
 
Array< T > & swap (size_t i1, size_t i2)
 Swaps two elements in this array.
 
void sort (CompareFnc cmp)
 Sorts the elements of the array using a custom comparison function.
 
const T * asArrayPtr () const
 Returns the array storage as a C-style array pointer.
 
T * asArrayPtr ()
 Accesses the first element in the array.
 

Protected Types

enum  { kDefaultGrowthLength = 8 }
 

Static Protected Member Functions

static size_t quickSortPartition (T *data, size_t first, size_t last, CompareFnc cmp)
 The partition portion of the QuickSort algorithm.
 
static void quickSortRecursive (T *data, size_t first, size_t last, CompareFnc cmp)
 Recursive QuickSort function used to sort the elements of the array.
 
static void handleOutOfMemory ()
 Utility function, called when the array fails to allocate memory.
 
static T * ArrayAllocate (size_t len)
 Allocates an array of elements without constructing them.
 
static void ArrayConstruct (T *arrayBegin, size_t len, const T &defaultVal)
 Constructs an array of elements.
 
static void ArrayDeAllocate (T *arrayBegin)
 De-allocates an array of elements without destructing them.
 
static void ArrayDestruct (T *arrayBegin, size_t len)
 Destructs an array of elements.
 
static void ArrayCopy (T *pCopy, size_t nMaxCount, const T *pSource, size_t nCount)
 Copies an array of elements to an already-constructed buffer.
 
static void ArrayCopyOverlap (T *pCopy, size_t nMaxCount, const T *pSource, size_t nCount)
 Copies an array of elements when the target and destination memory buffers may overlap.
 
static void ArrayCopyConstruct (T *pCopy, size_t nMaxCount, const T *pSource, size_t nCount)
 Copies and array of elements to a non-constructed.
 

Protected Attributes

T * mpArray
 Pointer to the storage buffer.
 
size_t mReservedLen
 The reserved length (in number of elements, not bytes).
 
size_t mUsedLen
 The used length (in number of elements, not bytes).
 
size_t mGrowLen
 The growth length. See setGrowLength().
 

Additional Inherited Members

- Static Public Member Functions inherited from MaxHeapOperators
static UtilExport voidoperator new (size_t size)
 Standard new operator used to allocate objects If there is insufficient memory, an exception will be thrown.
 
static UtilExport voidoperator new (size_t size, const std::nothrow_t &e)
 Standard new operator used to allocate objects if there is insufficient memory, NULL will be returned.
 
static UtilExport voidoperator new (size_t size, const char *filename, int line)
 New operator used to allocate objects that takes the filename and line number where the new was called If there is insufficient memory, an exception will be thrown.
 
static UtilExport voidoperator new (size_t size, int block_type, const char *filename, int line)
 New operator used to allocate objects that takes the type of memory, filename and line number where the new was called If there is insufficient memory, an exception will be thrown.
 
static UtilExport voidoperator new (size_t size, const std::nothrow_t &e, const char *filename, int line)
 New operator used to allocate objects that takes the filename and line number where the new was called If there is insufficient memory, NULL will be returned.
 
static UtilExport voidoperator new (size_t size, unsigned long flags)
 New operator used to allocate objects that takes extra flags to specify special operations If there is insufficient memory, an exception will be thrown.
 
static UtilExport voidoperator new (size_t size, const std::nothrow_t &e, unsigned long flags)
 New operator used to allocate objects that takes extra flags to specify special operations If there is insufficient memory, NULL will be returned.
 
static UtilExport voidoperator new[] (size_t size)
 New operator used to allocate arrays of objects If there is insufficient memory, an exception will be thrown.
 
static UtilExport voidoperator new[] (size_t size, const std::nothrow_t &e)
 New operator used to allocate arrays of objects If there is insufficient memory, NULL will be returned.
 
static UtilExport voidoperator new[] (size_t size, const char *filename, int line)
 New operator used to allocate arrays of objects If there is insufficient memory, an exception will be thrown.
 
static UtilExport voidoperator new[] (size_t size, int block_type, const char *filename, int line)
 New operator used to allocate arrays of objects.
 
static UtilExport voidoperator new[] (size_t size, const std::nothrow_t &e, const char *filename, int line)
 New operator used to allocate arrays of objects If there is insufficient memory, NULL will be returned.
 
static UtilExport voidoperator new[] (size_t size, unsigned long flags)
 New operator used to allocate arrays of objects If there is insufficient memory, an exception will be thrown.
 
static UtilExport voidoperator new[] (size_t size, const std::nothrow_t &e, unsigned long flags)
 New operator used to allocate arrays of objects If there is insufficient memory, NULL will be returned.
 
static UtilExport void operator delete (void *ptr)
 Standard delete operator used to deallocate an object If the pointer is invalid, an exception will be thrown.
 
static UtilExport void operator delete (void *ptr, const std::nothrow_t &e)
 Standard delete operator used to deallocate an object If the pointer is invalid, nothing will happen.
 
static UtilExport void operator delete (void *ptr, const char *filename, int line)
 Delete operator used to deallocate an object that takes the filename and line number where the delete was called If the pointer is invalid, an exception will be thrown.
 
static UtilExport void operator delete (void *ptr, int block_type, const char *filename, int line)
 Delete operator used to deallocate an object that takes the type of memory, filename and line number where the delete was called If the pointer is invalid, an exception will be thrown.
 
static UtilExport void operator delete (void *ptr, const std::nothrow_t &e, const char *filename, int line)
 Delete operator used to deallocate an object that takes the filename and line number where the delete was called If the pointer is invalid, nothing will happen.
 
static UtilExport void operator delete (void *ptr, unsigned long flags)
 Delete operator used to deallocate an object that takes extra flags to specify special operations If the pointer is invalid, an exception will be thrown.
 
static UtilExport void operator delete (void *ptr, const std::nothrow_t &e, unsigned long flags)
 Delete operator used to deallocate an object that takes extra flags to specify special operations If the pointer is invalid, nothing will happen.
 
static UtilExport void operator delete[] (void *ptr)
 Standard delete operator used to deallocate an array of objects If the pointer is invalid, an exception will be thrown.
 
static UtilExport void operator delete[] (void *ptr, const std::nothrow_t &e)
 Standard delete operator used to deallocate an array of objects If the pointer is invalid, nothing will happen.
 
static UtilExport void operator delete[] (void *ptr, const char *filename, int line)
 Delete operator used to deallocate an array of objects that takes the filename and line number where the delete was called If the pointer is invalid, an exception will be thrown.
 
static UtilExport void operator delete[] (void *ptr, int block_type, const char *filename, int line)
 Delete operator used to deallocate an array of objects that takes the type of memory, filename and line number where the delete was called If the pointer is invalid, an exception will be thrown.
 
static UtilExport void operator delete[] (void *ptr, const std::nothrow_t &e, const char *filename, int line)
 Delete operator used to deallocate an array of objects that takes the filename and line number where the delete was called If the pointer is invalid, nothing will happen.
 
static UtilExport void operator delete[] (void *ptr, unsigned long flags)
 Delete operator used to deallocate an array of objects that takes extra flags to specify special operations If the pointer is invalid, an exception will be thrown.
 
static UtilExport void operator delete[] (void *ptr, const std::nothrow_t &e, unsigned long flags)
 Delete operator used to deallocate an array of objects that takes extra flags to specify special operations If the pointer is invalid, an exception will be thrown.
 
static UtilExport voidoperator new (size_t size, void *placement_ptr)
 Placement new operator.
 
static UtilExport void operator delete (void *ptr, void *placement_ptr)
 Placement delete operator.
 
static UtilExport voidaligned_malloc (size_t size, size_t alignment)
 Allocates memory on a specified alignment boundary.
 
static UtilExport voidaligned_realloc (void *ptr, size_t size, size_t alignment)
 Reallocates memory on a specified alignment boundary.
 
static UtilExport void aligned_free (void *ptr)
 Frees a block of memory that was allocated with aligned_malloc/aligned_realloc.
 

Detailed Description

template<class T>
class MaxSDK::Array< T >

A generic array container, with proper support for non-POD types.

This template class is a generic, dynamic array container, similar to the STL class "vector". Whereas the classical 3ds Max SDK class Tab supports only POD types, this class supports non-POD types as well.

Note
POD stands for "plain old data", and basically denotes any data type which does not need to be constructed, destructed, and which can be copied with memcpy() rather than requiring a copy operator to be called.

Member Typedef Documentation

◆ CompareFnc

typedef int(__cdecl * CompareFnc) (const void *elem1, const void *elem2)

Type of function to pass to sort().

Must return:
  • < 0 if elem1 is smaller than elem2,
  • > 0 if elem 1 is greater,
  • or 0 if they're equal.

Member Enumeration Documentation

◆ anonymous enum

anonymous enum
protected
Enumerator
kDefaultGrowthLength 

The default growth length. See setGrowLength().

337 {
340 };
@ kDefaultGrowthLength
The default growth length. See setGrowLength().
Definition: Array.h:339

Constructor & Destructor Documentation

◆ Array() [1/4]

Initializes an empty array.

22: mpArray(NULL),
23 mReservedLen(0),
24 mUsedLen(0),
26{
27 if(mGrowLen < 1) {
28 // Growth length needs to be at least 1.
29 mGrowLen = 1;
30 }
31}
#define NULL
Definition: autoptr.h:18
T * mpArray
Pointer to the storage buffer.
Definition: Array.h:343
size_t mReservedLen
The reserved length (in number of elements, not bytes).
Definition: Array.h:345
size_t mUsedLen
The used length (in number of elements, not bytes).
Definition: Array.h:347
size_t mGrowLen
The growth length. See setGrowLength().
Definition: Array.h:349

◆ Array() [2/4]

Array ( size_t  initUsedLength,
const T &  defaultVal = T(),
size_t  initGrowLength = kDefaultGrowthLength 
)

Initializes an array with an initial size.

Parameters
[in]initUsedLength- Number of elements initially allocated in the array.
[in]defaultVal- The default value for the elements initially allocated.
[in]initGrowLength- The initial growth length of the array. For more information on the growth length, see setGrowLength().
34: mpArray(NULL),
35 mReservedLen(0),
36 mUsedLen(0),
38{
39 if(mGrowLen < 1) {
40 // Growth length needs to be at least 1.
41 mGrowLen = 1;
42 }
43
44 // Re-size the array if a non-zero length was specified.
45 if(usedLength > 0) {
46 mpArray = ArrayAllocate(usedLength);
47 if (mpArray == NULL) {
49 }
50 else {
51
52 // Initialize the new elements
53 ArrayConstruct(mpArray, usedLength, defaultVal);
54
55 mReservedLen = usedLength;
56 mUsedLen = usedLength;
57 }
58 }
59}
size_t growLength() const
Returns the growth length of the array.
Definition: Array.inline.h:180
static T * ArrayAllocate(size_t len)
Allocates an array of elements without constructing them.
Definition: Array.inline.h:21
static void ArrayConstruct(T *arrayBegin, size_t len, const T &defaultVal)
Constructs an array of elements.
Definition: Array.inline.h:31
static void handleOutOfMemory()
Utility function, called when the array fails to allocate memory.
Definition: Array.inline.h:360

◆ Array() [3/4]

Array ( const Array< T > &  src)

Copy constructor.

Copies the contents of another array.

Parameters
[in]src- Array from which the elements are copied.
69: mpArray(NULL),
70 mReservedLen(src.mUsedLen),
71 mUsedLen(src.mUsedLen),
72 mGrowLen(src.mGrowLen)
73{
74 if (mReservedLen > 0) {
76 if (mpArray == NULL) {
78 mReservedLen = 0;
79 mUsedLen = 0;
80 }
81 else {
83 }
84 }
85}
static void ArrayCopyConstruct(T *pCopy, size_t nMaxCount, const T *pSource, size_t nCount)
Copies and array of elements to a non-constructed.
Definition: Array.inline.h:128

◆ Array() [4/4]

Array ( InputIt  begin,
InputIt  end 
)

Copy constructor.

Copies the contents values between 2 iterators.

Parameters
[in]begin- iterator that defines where to start copying from
[in]end- iterator that defines when to stop copying
90 : mpArray(nullptr)
91 , mReservedLen(0)
92 , mUsedLen(0)
94{
95 size_t count = end - begin;
96
97 mpArray = ArrayAllocate(count);
98 if (mpArray == nullptr)
99 {
101 }
102
103 mReservedLen = count;
104 mUsedLen = count;
105
106 // todo trivially copyable
107 T* place = mpArray;
108 for (; begin != end; ++begin) {
109 new(place) T(*begin);
110 ++place;
111 }
112}
T * begin()
Accesses the begin iterator, which is a plain pointer in this case.
Definition: Array.inline.h:275
T * end()
Accesses the end iterator (one past last valid element). Do not dereference.
Definition: Array.inline.h:305

◆ ~Array()

Destructor. Destroys every element stored in the array, and frees the allocated storage.

115{
116 // The type stored by MaxSDK::Array must be trivial or it must have a copy constructor and a copy assignment operator
117 // for ArrayCopyConstruct, ArrayCopy and ArrayCopyOverlap to work
118 static_assert(std::is_trivial<T>::value || (std::is_copy_constructible<T>::value),
119 "The type stored by MaxSDK::Array must be trivial or it must have a copy constructor.");
120 static_assert(std::is_trivial<T>::value || (std::is_copy_assignable<T>::value),
121 "The type stored by MaxSDK::Array must be trivial or it must have a copy assignment operator.");
122
123 if (mpArray != NULL) {
126 }
127}
static void ArrayDeAllocate(T *arrayBegin)
De-allocates an array of elements without destructing them.
Definition: Array.inline.h:40
static void ArrayDestruct(T *arrayBegin, size_t len)
Destructs an array of elements.
Definition: Array.inline.h:45

Member Function Documentation

◆ operator=()

Array< T > & operator= ( const Array< T > &  src)

Copy operator.

Copies the contents of another array.

Parameters
[in]src- Array from which the elements are copied.
Returns
A reference to 'this'.
139{
140 if (this != &src) {
141 // Re-allocate the buffer if necessary
142 if (mReservedLen < src.mUsedLen) {
143 // Destroy the existing list
144 if (mpArray != NULL) {
147 }
148 // Allocate a new buffer
149 mReservedLen = src.mUsedLen;
151 if (mpArray == NULL) { // ...so this only happens if failure.
153 mReservedLen = 0;
154 mUsedLen = 0;
155 return *this;
156 }
157 // Copy the list
158 mUsedLen = src.mUsedLen;
160 }
161 else if(mUsedLen < src.mUsedLen) {
162 // The entire destination list is to be overwritten
163 ArrayCopy(mpArray, mUsedLen, src.mpArray, mUsedLen);
164 // Remaining elements need to be added to the list
165 ArrayCopyConstruct(mpArray + mUsedLen, mReservedLen - mUsedLen, src.mpArray + mUsedLen, src.mUsedLen - mUsedLen);
166 mUsedLen = src.mUsedLen;
167 }
168 else if(mUsedLen > src.mUsedLen) {
169 // Copy the entire source list.
170 ArrayCopy(mpArray, mUsedLen, src.mpArray, src.mUsedLen);
171 // Truncate unused elements in the destination list.
172 ArrayDestruct(mpArray + src.mUsedLen, mUsedLen - src.mUsedLen);
173 mUsedLen = src.mUsedLen;
174 }
175 else {
176 // Lists are of identical size; simply copy the entire contents
177 ArrayCopy(mpArray, mReservedLen, src.mpArray, mUsedLen);
178 }
179 }
180 return *this;
181}
static void ArrayCopy(T *pCopy, size_t nMaxCount, const T *pSource, size_t nCount)
Copies an array of elements to an already-constructed buffer.
Definition: Array.inline.h:58

◆ operator==()

bool operator== ( const Array< T > &  op) const

Equality operator.

Parameters
[in]op- Array to be compared to 'this'.
Returns
true if and only if both arrays contain the same number of elements and each of these elements if equal to the corresponding element from the other Array.
191{
192 if (mUsedLen == cpr.mUsedLen)
193 {
194 for (size_t i = 0; i < mUsedLen; i++)
195 if (mpArray[i] != cpr.mpArray[i])
196 return false;
197 return true;
198 }
199 return false;
200}

◆ operator[]() [1/2]

T & operator[] ( size_t  i)
inline

Subscript operator.

Parameters
[in]i- Index of array element to access. This index must be within the array bounds. If the index is out of bounds it will throw a MaxSDK::Util::MaxOutOfRangeException exception.
Returns
A reference to the array element at the specified index.
Remarks
Does implement bounds checking.
202{
203 if (!isValidIndex(i))
204 {
205 DbgAssert(false);
206 throw MaxSDK::Util::OutOfRangeException(_M("Argument index out of bounds, passed into a MaxSDK::Array::operator[]"));
207 }
208 return mpArray[i];
209}
bool isValidIndex(size_t) const
Returns whether the given array index is valid for this array.
Definition: Array.inline.h:195
Thrown when an out of bounds index is detected.
Definition: MaxExceptions.h:53
#define DbgAssert(expr)
Definition: assert1.h:83
#define _M(x)
Used to wrap string literals.
Definition: strbasic.h:67

◆ operator[]() [2/2]

const T & operator[] ( size_t  i) const
inline

Subscript operator.

Parameters
[in]i- Index of array element to access. This index must be within the array bounds. If the index is out of bounds it will throw a MaxSDK::Util::MaxOutOfRangeException exception.
Returns
A reference to the array element at the specified index.
Remarks
Does implement bounds checking.
212{
213 if (!isValidIndex(i))
214 {
215 DbgAssert(false);
216 throw MaxSDK::Util::OutOfRangeException(_M("Argument index out of bounds, passed into a MaxSDK::Array::operator[]"));
217 }
218 return mpArray[i];
219}

◆ at() [1/2]

const T & at ( size_t  index) const
inline

Same as subscript operator.

Parameters
[in]index- Index of array element to access. This index must be within the array bounds.
Returns
A reference to the array element at the specified index.
Remarks
Does not implement bounds checking.
232{
233 if (!isValidIndex(i))
234 {
235 DbgAssert(false);
236 throw MaxSDK::Util::OutOfRangeException(_M("Argument index out of bounds, passed into a MaxSDK::Array::at()"));
237 }
238 return mpArray[i];
239}

◆ at() [2/2]

T & at ( size_t  index)
inline

Same as subscript operator.

Parameters
[in]index- Index of array element to access. This index must be within the array bounds.
Returns
A reference to the array element at the specified index.
Remarks
Does not implement bounds checking.
222{
223 if (!isValidIndex(i))
224 {
225 DbgAssert(false);
226 throw MaxSDK::Util::OutOfRangeException(_M("Argument index out of bounds, passed into a MaxSDK::Array::at()"));
227 }
228 return mpArray[i];
229}

◆ setAt()

Array< T > & setAt ( size_t  index,
const T &  value 
)
inline

Sets a copy of value at the given index.

Parameters
[in]index- The position in the array where a copy of value is placed. This index must be within the array bounds.
[in]value- a reference to the original object.
Returns
A reference to 'this'.
Remarks
Does not implement bounds checking.
242{
243 if (!isValidIndex(i))
244 {
245 DbgAssert(false);
246 throw MaxSDK::Util::OutOfRangeException(_M("Argument index out of bounds, passed into a MaxSDK::Array::setAt()"));
247 }
248 mpArray[i] = value;
249 return *this;
250}

◆ setAll()

Array< T > & setAll ( const T &  value)

Sets all the elements of the array to the given value.

Parameters
[in]value- The value to which the elements of the array are set.
Returns
A reference to 'this'.
206{
207 for (size_t i = 0; i < mUsedLen; i++) {
208 mpArray[i] = value;
209 }
210 return *this;
211}

◆ first() [1/2]

T & first
inline

Accesses the first element in the array.

Returns
A reference to the first element of the array.
Remarks
It is invalid to call this on an empty array.
253{
254 DbgAssert(!this->isEmpty());
255 DbgAssert(mpArray != nullptr);
256 if (this->isEmpty() || (nullptr == mpArray))
257 {
258 throw MaxSDK::Util::RunTimeException(_M("Attempting to call MaxSDK::Array::first() on an empty array"));
259 }
260 return mpArray[0];
261}
bool isEmpty() const
Returns true if the number of used elements in the array is 0; returns false otherwise.
Definition: Array.inline.h:165
General multi-purpose exception for runtime errors.
Definition: MaxExceptions.h:69

◆ first() [2/2]

const T & first
inline

Accesses the first element in the array.

Returns
A reference to the first element of the array.
Remarks
It is invalid to call this on an empty array.
264{
265 DbgAssert(!this->isEmpty());
266 DbgAssert(mpArray != nullptr);
267 if (this->isEmpty() || (nullptr == mpArray))
268 {
269 throw MaxSDK::Util::RunTimeException(_M("Attempting to call MaxSDK::Array::first() on an empty array"));
270 }
271 return mpArray[0];
272}

◆ begin() [1/2]

T * begin

Accesses the begin iterator, which is a plain pointer in this case.

275 {
276 return mpArray;
277}

◆ begin() [2/2]

const T * begin

Accesses the const begin iterator, which is a plain pointer in this case.

279 {
280 return mpArray;
281}

◆ last() [1/2]

T & last
inline

Accesses the last element in the array.

Returns
A reference to the last element of the array.
Remarks
It is invalid to call this on an empty array.
284{
285 DbgAssert(!this->isEmpty());
286 DbgAssert(mpArray != nullptr);
287 if (this->isEmpty() || (nullptr == mpArray))
288 {
289 throw MaxSDK::Util::RunTimeException(_M("Attempting to call MaxSDK::Array::last() on an empty array"));
290 }
291 return mpArray[mUsedLen-1];
292}

◆ last() [2/2]

const T & last
inline

Accesses the first element in the array.

Returns
A reference to the first element of the array.
Remarks
It is invalid to call this on an empty array.
295{
296 DbgAssert(!this->isEmpty());
297 DbgAssert(mpArray != nullptr);
298 if (this->isEmpty() || (nullptr == mpArray))
299 {
300 throw MaxSDK::Util::RunTimeException(_M("Attempting to call MaxSDK::Array::last() on an empty array"));
301 }
302 return mpArray[mUsedLen-1];
303}

◆ end() [1/2]

T * end

Accesses the end iterator (one past last valid element). Do not dereference.

305 {
306 return mpArray + mUsedLen;
307}

◆ end() [2/2]

const T * end

Accesses the const end iterator (one past last valid element). Do not dereference.

309 {
310 return mpArray + mUsedLen;
311}

◆ append() [1/3]

size_t append ( const T &  value)
inline

Appends a copy of value to the array.

Parameters
[in]value- A reference to the original value.
Returns
The number of elements in the array prior to the append operation.
314{
315 insertAt(mUsedLen, value);
316 return mUsedLen-1;
317}
Array< T > & insertAt(size_t index, const T &value)
Inserts a single value, at a given location, into this array.
Definition: Array.imp.h:243

◆ append() [2/3]

Array< T > & append ( const T *  values,
size_t  count 
)

Appends one or more element(s) to the array.

Parameters
[in]values- A pointer to a C-style array of elements, from which the appended elements will be copied.
[in]count- The number of elements to be appended.
Returns
A reference to 'this'.
320{
321 return insertAt(mUsedLen, values, count);
322}

◆ append() [3/3]

Array< T > & append ( const Array< T > &  array)

Appends the contents of another array to this array.

Parameters
[in]array- The array from which elements are to be appended.
Returns
A reference to 'this'.
220{
221 size_t otherLen = otherArray.length();
222 if (otherLen == 0) {
223 return *this;
224 }
225 size_t newLen = mUsedLen + otherLen;
226 if (newLen > mReservedLen) {
227 setLengthReserved(newLen);
228 }
229
230 ArrayCopyConstruct(mpArray + mUsedLen, mReservedLen - mUsedLen, otherArray.mpArray, otherLen);
231
232 mUsedLen = newLen;
233 return *this;
234}
Array< T > & setLengthReserved(size_t length)
Sets the number of elements allocated/reserved (as opposed to actually used) in the array.
Definition: Array.imp.h:463

◆ insertAt() [1/2]

Array< T > & insertAt ( size_t  index,
const T &  value 
)

Inserts a single value, at a given location, into this array.

Parameters
[in]index- The index at which the element is to be inserted. This index must be smaller or equal to the used length of the array.
[in]value- The value to be inserted.
Returns
A reference to 'this'.
244{
245 DbgAssert(index >= 0 && index <= mUsedLen);
246
247 if (mUsedLen >= mReservedLen) {
249 }
250
251 if (index != mUsedLen) {
252
253 // Initialize the new member of the array
255
256 // Copy the remainder of the list that needs to be shifted
257 for(size_t i = mUsedLen - 1; i > index; --i) {
258 mpArray[i] = mpArray[i-1];
259 }
260
261 // Now copy the new element into the array
262 mpArray[index] = value;
263 }
264 else {
265 // Add the new value to the end of the list
267 }
268
269 mUsedLen++;
270 return *this;
271}

◆ insertAt() [2/2]

Array< T > & insertAt ( size_t  index,
const T *  values,
size_t  count 
)

Inserts a one or more value(s), at a given location, into this array.

Parameters
[in]index- The index at which the element is to be inserted. This index must be smaller or equal to the used length of the array.
[in]values- A pointer to a C-style array of elements, from which the inserted elements will be copied.
[in]count- The number of elements to be inserted.
Returns
A reference to 'this'.
274{
275 DbgAssert(index >= 0 && index <= mUsedLen);
276
277 if(index <= mUsedLen) {
278
279 size_t lastInsertIndex = index + count - 1;
280
281 // Increase the allocated memory if necessary
282 size_t newUsedLen = mUsedLen + count;
283 if(newUsedLen > mReservedLen) {
284
285 // Allocate a new buffer
286 T* newArray = ArrayAllocate(newUsedLen);
287 if(newArray == NULL) {
288 // Can't insert the new element since the allocation failed.
290 return *this;
291 }
292
293 // Copy existing elements located to the left of the insertion range
294 ArrayCopyConstruct(newArray, newUsedLen, mpArray, index);
295
296 // Copy the inserted elements
297 ArrayCopyConstruct(newArray + index, newUsedLen - index, values, count);
298
299 // Copy existing elements located to the right of the insertion range
300 if(index < mUsedLen) {
301 ArrayCopyConstruct(newArray + index + count, newUsedLen - index - count, mpArray + index, mUsedLen - index);
302 }
303
304 // Destroy the old array
307
308 mpArray = newArray;
309 mUsedLen = newUsedLen;
310 mReservedLen = newUsedLen;
311 }
312 else {
313 if(index < mUsedLen) {
314 // Shift elements that get moved beyond the current limit of the array
316
317 // Shift elements that stay inside the current limits of the array
318 if((index + count) < mUsedLen) {
319 ArrayCopyOverlap(mpArray + index + count, mReservedLen - index - count, mpArray + index, mUsedLen - index - count);
320 }
321
322 // Copy new elements that get inserted within the current size of the array
323 if(lastInsertIndex < mUsedLen) {
324 ArrayCopy(mpArray + index, mReservedLen - index, values, count);
325 }
326 else {
327 ArrayCopy(mpArray + index, mReservedLen - index, values, mUsedLen - index);
328 }
329 }
330
331 // Copy new elements that get inserted beyond the current size of the array
332 if(lastInsertIndex >= mUsedLen) {
333 size_t numElementsInserted = (mUsedLen - index);
334 DbgAssert(numElementsInserted < count);
335 ArrayCopyConstruct(mpArray + mUsedLen, mReservedLen - mUsedLen, values + numElementsInserted, count - numElementsInserted);
336 }
337
338 mUsedLen += count;
339 }
340 }
341
342 return *this;
343}
static void ArrayCopyOverlap(T *pCopy, size_t nMaxCount, const T *pSource, size_t nCount)
Copies an array of elements when the target and destination memory buffers may overlap.
Definition: Array.inline.h:83

◆ removeAt()

Array< T > & removeAt ( size_t  index)

Removes a single element from the array.

Parameters
[in]index- The index of the element to be removed. This index must be valid (within bounds).
Returns
A reference to 'this'.
349{
350 DbgAssert(isValidIndex(index));
351
352 if(index < mUsedLen) {
353 // Shift array elements to the left if needed.
354 //
355 if (index < mUsedLen - 1) {
356 for(size_t i = index; i < mUsedLen - 1; ++i) {
357 mpArray[i] = mpArray[i+1];
358 }
359 }
360
361 // Destroy the last element of the array
363
364 mUsedLen--;
365 }
366
367 return *this;
368}

◆ remove()

bool remove ( const T &  value,
size_t  start = 0 
)

Searches for a value in the array and, if it is found, removes it from the array.

Parameters
[in]value- The value to search for.
[in]start- The index at which to start searching. Preceding elements are not searched.
Returns
true if a value was found & removed; false otherwise.
Remarks
If multiple copies of the same value are stored in the array, only the first instance will be removed.
561{
562 const size_t i = this->findFrom(value, start);
563 if (i == -1)
564 return false;
565 this->removeAt(i);
566 return true;
567}
size_t findFrom(const T &value, size_t start) const
Searches for a value in the array, starting at a given index.
Definition: Array.imp.h:420
Array< T > & removeAt(size_t index)
Removes a single element from the array.
Definition: Array.imp.h:348

◆ removeFirst()

Array< T > & removeFirst
inline

Removes the first element of the array.

Returns
A reference to 'this'.
Remarks
Must not be called on an empty array.
325{
326 DbgAssert(!isEmpty());
327 return removeAt(0);
328}

◆ removeLast()

Array< T > & removeLast
inline

Removes the last element of the array.

Returns
A reference to 'this'.
Remarks
Must not be called on an empty array.
331{
332 DbgAssert(!isEmpty());
333 return removeAt(mUsedLen - 1);
334}

◆ removeAll()

Array< T > & removeAll
inline

Removes all the elements from the array.

Returns
A reference to 'this'.
337{
338 if(mUsedLen > 0) {
340 mUsedLen = 0;
341 }
342 return *this;
343}

◆ removeSubArray()

Array< T > & removeSubArray ( size_t  startIndex,
size_t  endIndex 
)

Removes a subset of the array.

Parameters
[in]startIndex- The index of the first element to be removed.
[in]endIndex- The index of the last element to be removed.
Returns
A reference to 'this'.
Remarks
  • Both the start and end indices must be within bounds.
  • The end index must be greater or equal to the start index.
374{
375 DbgAssert(isValidIndex(startIndex));
376 DbgAssert(startIndex <= endIndex);
377
378 if(startIndex < mUsedLen) {
379
380 if(endIndex >= mUsedLen) {
381 endIndex = mUsedLen - 1;
382 }
383
384 size_t numToRemove = endIndex - startIndex + 1;
385
386 // Shift all elements that reside on the right of the sub-array to be removed
387 for(size_t i = endIndex + 1; i < mUsedLen; ++i) {
388 mpArray[i - numToRemove] = mpArray[i];
389 }
390
391 // Truncate the array
392 ArrayDestruct(mpArray + mUsedLen - numToRemove, numToRemove);
393
394 mUsedLen -= numToRemove;
395 }
396
397 return *this;
398}

◆ contains()

bool contains ( const T &  value,
size_t  start = 0 
) const
inline

Determines if a value is stored in the array.

Parameters
[in]value- The value for which to search for.
[in]start- The index at which to start searching. Preceding elements are not searched.
Returns
true if the value was found in the array; false otherwise.
156{
157 return this->findFrom(value, start) != -1;
158}

◆ find() [1/2]

bool find ( const T &  value,
size_t foundAt,
size_t  start = 0 
) const

Searches for a value in the array.

Parameters
[in]value- The value to search for.
[out]foundAt- The index at which the value was found. Indeterminate if the value was not found.
[in]start- The index at which to start searching. Preceding elements are not searched.
Returns
true if the value was found in the array; false otherwise.
407{
408 const size_t nFoundAt = this->findFrom(value, start);
409 if (nFoundAt == -1)
410 return false;
411 index = nFoundAt;
412 return true;
413}

◆ find() [2/2]

size_t find ( const T &  value) const

Searches for a value in the array.

Parameters
[in]value- The value to search for.
Returns
The index at which the value was found, or -1 if the value was not found. (Since this returns an unsigned value, -1 is converted to the the largest positive value).
416{
417 return this->findFrom(value, 0); // search from the beginning
418}

◆ findFrom()

size_t findFrom ( const T &  value,
size_t  start 
) const

Searches for a value in the array, starting at a given index.

Parameters
[in]value- The value to search for.
[in]start- The index at which to start searching.
Returns
The index at which the value was found, or -1 if the value was not found. (Since this returns an unsigned value, -1 is converted to the the largest positive value).
421{
422 for (size_t i = start; i < this->mUsedLen; i++) {
423 if (mpArray[i] == value)
424 return i;
425 }
426 return (size_t)-1;
427}

◆ length()

size_t length
inline

Returns the number of used elements (as opposed to simply allocated/reserved) in the array.

161{
162 return mUsedLen;
163}

◆ isEmpty()

bool isEmpty
inline

Returns true if the number of used elements in the array is 0; returns false otherwise.

166{
167 return mUsedLen == 0;
168}

◆ lengthUsed()

size_t lengthUsed
inline

Returns the number of elements used (as opposed to simply allocated/reserved) in the array.

171{
172 return mUsedLen;
173}

◆ setLengthUsed()

Array< T > & setLengthUsed ( size_t  length,
const T &  defaultVal = T() 
)

Sets the number of elements used (as opposed to simply allocated/reserved) in the array.

Parameters
[in]length- The new "used length" of the array.
[in]defaultVal- The default value for new elements, used only if the length of the array is increased.
Returns
A reference to 'this'.
437{
438 DbgAssert(n >= 0);
439 if (n > mReservedLen) {
440 // We over-allocate some extra slack
441 setLengthReserved(__max(n + mGrowLen, n + n / 2));
442 }
443
444 if(n > mUsedLen) {
445 // Initialize the new elements
446 ArrayConstruct(mpArray + mUsedLen, n - mUsedLen, defaultVal);
447 }
448 else {
449 // Destroy the elements to be removed
451 }
452
453 mUsedLen = n;
454 return *this;
455}

◆ lengthReserved()

size_t lengthReserved
inline

Returns the number of elements allocated/reserved (as opposed to actually used) in the array.

176{
177 return mReservedLen;
178}

◆ setLengthReserved()

Array< T > & setLengthReserved ( size_t  length)

Sets the number of elements allocated/reserved (as opposed to actually used) in the array.

Parameters
[in]length- The new "reserved length" of the array.
Returns
A reference to 'this'.
464{
465 DbgAssert(n >= 0);
466
467 if(n != mReservedLen) {
468
469 if(n == 0) {
470 if(mReservedLen > 0) {
473 mpArray = NULL;
474 mUsedLen = 0;
475 mReservedLen = 0;
476 }
477 }
478 else if(mReservedLen == 0) {
480 if(mpArray == NULL) {
481 // Failure to allocate memory; can't increase the reserved length.
483 return *this;
484 }
485 mReservedLen = n;
486 }
487 else {
488 T* oldArray = mpArray;
489 size_t oldUsedLen = mUsedLen;
490
491 // Allocate the new array
493 if(mpArray == NULL) {
494 // Failure to allocate memory; can't change the reserved length.
496 mpArray = oldArray;
497 return *this;
498 }
499
500 // Copy the old array to the new one.
501 if(n < mUsedLen) {
502 // The old members don't all fit in the new array
503 ArrayCopyConstruct(mpArray, n, oldArray, n);
504 mUsedLen = n;
505 }
506 else {
507 ArrayCopyConstruct(mpArray, n, oldArray, mUsedLen);
508 }
509 mReservedLen = n;
510
511 // Destroy the old array
512 ArrayDestruct(oldArray, oldUsedLen);
513 ArrayDeAllocate(oldArray);
514 }
515 }
516
517 return *this;
518}

◆ reserve()

void reserve ( size_t  capacity)

Alias for setLengthReserved.

Sets the number of elements allocated/reserved (as opposed to actually used) in the array. Named to be similar to the STL containers.

Parameters
[in]capacity- The new "reserved length" or possible capacity of the array.
521{
522 setLengthReserved(capacity);
523}

◆ growLength()

size_t growLength
inline

Returns the growth length of the array.

For more information on the growth length, see setGrowLength().

181{
182 return mGrowLen;
183}

◆ setGrowLength()

Array< T > & setGrowLength ( size_t  glen)
inline

Sets the growth length of the array.

The growth length is the minimum number elements by which the reserved space is grown whenever the array runs out of reserved space.

346{
347 DbgAssert(glen > 0);
348 if(glen > 0) {
349 mGrowLen = glen;
350 }
351 else {
352 DbgAssert(false);
353 // Growth length needs to be at least 1.
354 mGrowLen = 1;
355 }
356 return *this;
357}

◆ reverse()

Array< T > & reverse

Reverses the sequence of elements in the array.

Reverses the sequence of elements in the array such that the last element becomes the first.

Returns
A reference to 'this'.
530{
531 size_t halfUsedLen = mUsedLen/2;
532 for (size_t i = 0; i < halfUsedLen; i++) {
533 T tmp = mpArray[i];
534 mpArray[i] = mpArray[mUsedLen - 1 - i];
535 mpArray[mUsedLen - 1 - i] = tmp;
536 }
537 return *this;
538}

◆ swap()

Array< T > & swap ( size_t  i1,
size_t  i2 
)

Swaps two elements in this array.

Parameters
[in]i1- The index of the first element to swap. This index must be within bounds.
[in]i2- The index of the second element to swap. This index must be within bounds.
543{
546
547 if (i1 == i2) return *this;
548
549 T tmp = mpArray[i1];
550 mpArray[i1] = mpArray[i2];
551 mpArray[i2] = tmp;
552 return *this;
553}

◆ sort()

void sort ( CompareFnc  cmp)

Sorts the elements of the array using a custom comparison function.

The sort if performed with the QuickSort algorithm.

Parameters
[in]cmp- The comparison function used to order the elements.
See also
CompareFnc
570{
571 if (mUsedLen > 1)
572 {
573 // Use the standard C function if the type is trivial
574 // (meaning that memcpy() is safe)
575 if constexpr (std::is_trivial_v<T>)
576 {
577 qsort(mpArray, mUsedLen, sizeof(T), cmp);
578 }
579 else
580 {
581 quickSortRecursive(mpArray, 0, mUsedLen - 1, cmp);
582 }
583 }
584}
static void quickSortRecursive(T *data, size_t first, size_t last, CompareFnc cmp)
Recursive QuickSort function used to sort the elements of the array.
Definition: Array.imp.h:618

◆ asArrayPtr() [1/2]

const T * asArrayPtr
inline

Returns the array storage as a C-style array pointer.

Remarks
Any modification to the contents of the array, through this pointer, may be dangerous.
186{
187 return mpArray;
188}

◆ asArrayPtr() [2/2]

T * asArrayPtr
inline

Accesses the first element in the array.

Returns
A reference to the first element of the array.
Remarks
It is invalid to call this on an empty array.
191{
192 return mpArray;
193}

◆ isValidIndex()

bool isValidIndex ( size_t  i) const
inline

Returns whether the given array index is valid for this array.

Returns
true if the given index is within the bounds of this array; false otherwise.
196{
197 // We should prohibit index's that are the maximum size_t value
198 return (i != (size_t)-1) && i < mUsedLen;
199}

◆ quickSortPartition()

size_t quickSortPartition ( T *  data,
size_t  first,
size_t  last,
CompareFnc  cmp 
)
staticprotected

The partition portion of the QuickSort algorithm.

587{
588 const T& pivot = data[last]; // use the last item as the pivot
589 size_t left = first; // sort from the first item
590 size_t right = last - 1; // sort to the item excluding the pivot
591
592 do {
593 while ((left < last) && (cmp(&(data[left]), &pivot) <= 0))
594 {
595 ++left;
596 }
597 while ((right > first) && (cmp(&(data[right]), &pivot) >= 0))
598 {
599 --right;
600 }
601 if (left < right) {
602 T swapValue = data[left];
603 data[left] = data[right];
604 data[right] = swapValue;
605 }
606 } while (left < right);
607
608 if (cmp(&data[left], &pivot) > 0)
609 {
610 T swapValue = data[left];
611 data[left] = data[last];
612 data[last] = swapValue;
613 }
614
615 return left;
616}
T & first()
Accesses the first element in the array.
Definition: Array.inline.h:252
T & last()
Accesses the last element in the array.
Definition: Array.inline.h:283

◆ quickSortRecursive()

void quickSortRecursive ( T *  data,
size_t  first,
size_t  last,
CompareFnc  cmp 
)
staticprotected

Recursive QuickSort function used to sort the elements of the array.

619{
620 if (first < last)
621 {
622 size_t pivot_position = quickSortPartition(data, first, last, cmp);
623
624 // Protect against overflow. Normally the "if (first < last)" test would
625 // guard against this, but size_t is unsigned, meaning "right - 1" can result
626 // in a test of -1 > 0 when right is 0, which is an invalid unsigned inequality.
627 if (pivot_position > 0)
628 {
629 quickSortRecursive(data, first, pivot_position - 1, cmp);
630 }
631 quickSortRecursive(data, pivot_position + 1, last, cmp);
632 }
633}
static size_t quickSortPartition(T *data, size_t first, size_t last, CompareFnc cmp)
The partition portion of the QuickSort algorithm.
Definition: Array.imp.h:586

◆ handleOutOfMemory()

void handleOutOfMemory
inlinestaticprotected

Utility function, called when the array fails to allocate memory.

360 {
361
362 DbgAssert(false);
364}
UtilExport void UtilOutOfMemoryException()

◆ ArrayAllocate()

T * ArrayAllocate ( size_t  len)
inlinestaticprotected

Allocates an array of elements without constructing them.

22{
23 DbgAssert(len < 0x40000000); // 1G sanity check
24 T* p = (T*) UtilAllocateMemory(len * sizeof(T));
25 return p;
26}
UtilExport void * UtilAllocateMemory(size_t)

◆ ArrayConstruct()

void ArrayConstruct ( T *  arrayBegin,
size_t  len,
const T &  defaultVal 
)
inlinestaticprotected

Constructs an array of elements.

32{
33 for(size_t i = 0; i < len; ++i)
34 {
35 new(&(arrayBegin[i])) T(defaultVal);
36 }
37}

◆ ArrayDeAllocate()

void ArrayDeAllocate ( T *  arrayBegin)
inlinestaticprotected

De-allocates an array of elements without destructing them.

41{
42 UtilDeallocateMemory(arrayBegin);
43}
UtilExport void UtilDeallocateMemory(void *)

◆ ArrayDestruct()

void ArrayDestruct ( T *  arrayBegin,
size_t  len 
)
inlinestaticprotected

Destructs an array of elements.

46{
47 // prevent build warning in some cases (when constexpr conditional false)
48 UNUSED_PARAM(arrayBegin); UNUSED_PARAM(len);
49 if constexpr (!std::is_trivially_destructible_v<T>)
50 {
51 for (size_t i = 0; i < len; ++i)
52 {
53 arrayBegin[i].~T();
54 }
55 }
56}
#define UNUSED_PARAM(x)
Definition: BuildWarnings.h:13

◆ ArrayCopy()

void ArrayCopy ( T *  pCopy,
size_t  nMaxCount,
const T *  pSource,
size_t  nCount 
)
staticprotected

Copies an array of elements to an already-constructed buffer.

Will use the copy operator if needed.

59{
60 // prevent build warning in some cases (when constexpr conditional true)
61 UNUSED_PARAM(nMaxCount);
62 // Auto-detect whether it's safe to use memcpy() or whether we need
63 // to call the copy operator. We're counting on the fact that this condition,
64 // being resolvable at compile-time, will be removed by the optimizer.
65 if constexpr (std::is_copy_assignable_v<T>)
66 {
67 // Type has an assignment operator; use it.
68 for (size_t i = 0; i < nCount; ++i)
69 {
70 pCopy[i] = (pSource[i]);
71 }
72 }
73 else
74 {
75 // Type does not have an assignment operator; use memcpy() as it's usually faster.
76 if (nCount > 0)
77 {
78 memcpy_s(pCopy, nMaxCount * sizeof(T), pSource, nCount * sizeof(T));
79 }
80 }
81}

◆ ArrayCopyOverlap()

void ArrayCopyOverlap ( T *  pCopy,
size_t  nMaxCount,
const T *  pSource,
size_t  nCount 
)
staticprotected

Copies an array of elements when the target and destination memory buffers may overlap.

84{
85 // prevent build warning in some cases (when constexpr conditional true)
86 UNUSED_PARAM(nMaxCount);
87 // Auto-detect whether it's safe to use memcpy() or whether we need
88 // to call the copy operator. We're counting on the fact that this condition,
89 // being resolvable at compile-time, will be removed by the optimizer.
90 if constexpr (std::is_copy_assignable_v<T>)
91 {
92 // Type has an assignment operator; use it.
93 if (pCopy == pSource)
94 {
95 // nothing to do here, bail early
96 return;
97 }
98
99 if (pCopy < pSource)
100 {
101 // forward iteration
102 for (size_t i = 0; i < nCount; i++)
103 {
104 pCopy[i] = pSource[i];
105 }
106 }
107 else
108 {
109 // backward iteration
110 for (size_t i = nCount - 1; i != (size_t)-1; --i)
111 {
112 pCopy[i] = pSource[i];
113 }
114 }
115 }
116 else
117 {
118 // Type does not have an assignment operator; use memmove() as it's usually faster.
119 if (nCount > 0)
120 {
121 memmove_s(pCopy, nMaxCount * sizeof(T), pSource, nCount * sizeof(T));
122 }
123 }
124}
MAXMEM_EXTERN_C UtilExport size_t(__cdecl *MAX_msize)(void *memblock)

◆ ArrayCopyConstruct()

void ArrayCopyConstruct ( T *  pCopy,
size_t  nMaxCount,
const T *  pSource,
size_t  nCount 
)
staticprotected

Copies and array of elements to a non-constructed.

Will use the copy constructor if needed.

129{
130 // prevent build warning in some cases (when constexpr conditional true)
131 UNUSED_PARAM(nMaxCount);
132 // Auto-detect whether it's safe to use memcpy() or whether we need
133 // to call the copy operator. We're counting on the fact that this condition,
134 // being resolvable at compile-time, will be removed by the optimizer.
135 if constexpr (std::is_copy_constructible_v<T>)
136 {
137 // Type has an assignment operator; use it.
138 for (size_t i = 0; i < nCount; ++i)
139 {
140 new(&(pCopy[i])) T(pSource[i]); // using placement new.
141 }
142 }
143 else
144 {
145 // Type does not have an assignment operator; use memcpy() as it's usually faster.
146 if (nCount > 0)
147 {
148 memcpy_s(pCopy, nMaxCount * sizeof(T), pSource, nCount * sizeof(T));
149 }
150 }
151}

Member Data Documentation

◆ mpArray

T* mpArray
protected

Pointer to the storage buffer.

◆ mReservedLen

size_t mReservedLen
protected

The reserved length (in number of elements, not bytes).

◆ mUsedLen

size_t mUsedLen
protected

The used length (in number of elements, not bytes).

◆ mGrowLen

size_t mGrowLen
protected

The growth length. See setGrowLength().