Blend2D
2D Vector Graphics Engine
BLArray< T > Class Template Reference
template<typename T>
class BLArray< T >
class BLArray< T >
Array container (template) [C++ API].
Member Functions
Construction & Destruction
BLArray() noexcept
~BLArray() noexcept
Overloaded Operators
Common Functionality
Accessors
Data Manipulation
template<typename... Args>
template<typename... Args>
BLResult assignExternalData(T* data, size_t size, size_t capacity, BLDataAccessFlags accessFlags, BLDestroyExternalDataFunc destroyFunc = nullptr, void* userData = nullptr) noexcept
template<typename... Args>
template<typename... Args>
template<typename... Args>
Equality & Comparison
Search
Additional Inherited Members
Public Attributes inherited from BLObjectCoretemplate<typename T>BLArray<T>::BLArray(BLArray<T>&& other)noexcept[2/3][¶]
Move constructor.
- Note
- The
otherarray is always reset by a move construction, so it becomes an empty array.
template<typename T>BLArray<T>::BLArray(const BLArray<T>& other)noexcept[3/3][¶]
Copy constructor, performs weak copy of the data held by the other array.
template<typename T>BLArray<T>::operator bool() constexplicitnoexcept[¶]
Tests whether the array has items. Returns true if the array is not empty.
- Note
- This is essentially the opposite of
empty().
template<typename T>BLArray& BLArray<T>::operator=(BLArray<T>&& other)noexcept[1/2][¶]
Move assignment.
- Note
- The
otherarray is reset by move assignment, so its state after the move operation is the same as the default constructed array.
template<typename T>BLArray& BLArray<T>::operator=(const BLArray<T>& other)noexcept[2/2][¶]
Copy assignment, performs weak copy of the data held by the other array.
template<typename T>bool BLArray<T>::operator==(const BLArray<T>& other) constnoexcept[¶]
Returns true if this and other arrays are equal.
template<typename T>bool BLArray<T>::operator!=(const BLArray<T>& other) constnoexcept[¶]
Returns true if this and other arrays are not equal.
template<typename T>const T& BLArray<T>::operator[](size_t index) constnoexcept[¶]
Returns a read-only reference to the array item at the given index.
- Note
- This is the same as calling
at(index).
template<typename T>BLResult BLArray<T>::reset()noexcept[¶]
Resets the array into a default constructed state by clearing its content and releasing its memory.
- Note
- This function always returns BL_SUCCESS.
template<typename T>void BLArray<T>::swap(BLArray<T>& other)noexcept[¶]
Swaps the content of this array with the other array.
template<typename T>size_t BLArray<T>::size() constnoexcept[¶]
Returns the size of the array (number of items).
template<typename T>size_t BLArray<T>::capacity() constnoexcept[¶]
Returns the capacity of the array (number of items).
template<typename T>const T* BLArray<T>::data() constnoexcept[¶]
Returns a pointer to the array data.
template<typename T>const T* BLArray<T>::begin() constnoexcept[¶]
Returns a pointer to the array data (iterator compatibility).
template<typename T>const T* BLArray<T>::end() constnoexcept[¶]
Returns a pointer to the end of array data (iterator compatibility).
template<typename T>BLArrayView<T> BLArray<T>::view() constnoexcept[¶]
Returns the array data as BLArrayView<T>.
template<typename T>const T& BLArray<T>::at(size_t index) constnoexcept[¶]
Returns a read-only reference to the array item at the given index.
- Note
- The index must be valid, which means it has to be less than the array length. Accessing items out of range is undefined behavior that would be caught by assertions in debug builds.
template<typename T>const T& BLArray<T>::first() constnoexcept[¶]
Returns a read-only reference to the first item.
- Note
- The array must have at least one item otherwise calling
first()would point to the end of the array, which is not initialized, and such reference would be invalid. Debug builds would catch this condition with an assertion.
template<typename T>const T& BLArray<T>::last() constnoexcept[¶]
Returns a read-only reference to the last item.
- Note
- The array must have at least one item otherwise calling
last()would point to the end of the array, which is not initialized, and such reference would be invalid. Debug builds would catch this condition with an assertion.
template<typename T>BLResult BLArray<T>::clear()noexcept[¶]
Clears the content of the array.
- Note
- If the array uses a dynamically allocated memory and the instance is mutable the memory won't be released, it will be reused instead. Consider using
reset()if you want to release the memory in such case instead.
template<typename T>BLResult BLArray<T>::shrink()noexcept[¶]
Shrinks the capacity of the array to fit its length.
Some array operations like append() may grow the array more than necessary to make it faster when such manipulation operations are called consecutively. When you are done with modifications and you know the lifetime of the array won't be short you can use shrink() to fit its memory requirements to the number of items it stores, which could optimize the application's memory requirements.
template<typename T>BLResult BLArray<T>::reserve(size_t n)noexcept[¶]
Reserves the array capacity to hold at least n items.
template<typename T>BLResult BLArray<T>::truncate(size_t n)noexcept[¶]
Truncates the length of the array to maximum n items.
If the length of the array is less than nn then truncation does nothing.
template<typename T>BLResult BLArray<T>::resize(size_t n, const T& fill)noexcept[¶]
Resizes the array to n items.
If n is greater than the array length then all new items will be initialized by fill item.
template<typename T>BLResult BLArray<T>::makeMutable(T** dataOut)noexcept[¶]
Makes the array mutable by possibly creating a deep copy of the data if it's either read-only or shared with another array. Stores the pointer to the beginning of mutable data in dataOut.
template<typename T>BLResult BLArray<T>::modifyOp(BLModifyOp op, size_t n, T** dataOut)noexcept[¶]
Modify operation is similar to makeMutable, however, the op argument specifies the desired array operation, see BLModifyOp. The pointer returned in dataOut points to the first item to be either assigned or appended and it points to an uninitialized memory.
Please note that assignments mean to wipe out the whole array content and to set the length of the array to n. The caller is responsible for initializing the data returned in dataOut.
template<typename T>BLResult BLArray<T>::insertOp(size_t index, size_t n, T** dataOut)noexcept[¶]
Insert operation, the semantics is similar to modifyOp(), however, items are inserted at the given index instead of assigned or appended.
The caller is responsible for initializing the data returned in dataOut.
template<typename T> template<typename... Args>BLResult BLArray<T>::modify_v(BLModifyOp op, Args&&... args)noexcept[¶]
Similar to modifyOp(), but the items to assign/append to the array are given after the op argument.
- Note
- This is a varidic template that makes such modification easier if you have a constant number of items to assign or append.
template<typename T>BLResult BLArray<T>::assign(BLArray<T>&& other)noexcept[1/2][¶]
Move assignment, the same as operator=, but returns a BLResult instead of this.
template<typename T>BLResult BLArray<T>::assign(const BLArray<T>& other)noexcept[2/2][¶]
Copy assignment, the same as operator=, but returns a BLResult instead of this.
template<typename T>BLResult BLArray<T>::assignDeep(const BLArray<T>& other)noexcept[¶]
Copy assignment, but creates a deep copy of the other array instead of weak copy.
template<typename T> template<typename... Args>BLResult BLArray<T>::assign_v(Args&&... args)noexcept[¶]
Replaces the content of the array with variadic number of items passed in args....
template<typename T>BLResult BLArray<T>::assignData(const BLArrayView<T>& view)noexcept[1/2][¶]
Replaces the content of the array by items in the passed array view.
- Note
- The implementation can handle
viewpointing to the array's data as well, so it's possible to create a slice of the array if required.
template<typename T>BLResult BLArray<T>::assignData(const T* items, size_t n)noexcept[2/2][¶]
Replaces the content of the array items of length n.
- Note
- The implementation can handle items pointing to the array's data as well, so it's possible to create a slice of the array if required.
template<typename T>BLResult BLArray<T>::assignExternalData(T* data, size_t size, size_t capacity, BLDataAccessFlags accessFlags, BLDestroyExternalDataFunc destroyFunc = nullptr, void* userData = nullptr)noexcept[¶]
Assign an external buffer to the array, which would replace the existing content.
- Parameters
-
data External data buffer to use (cannot be NULL). size Size of the data buffer in items. capacity Capacity of the buffer, cannot be zero or smaller than size.accessFlags Flags that describe whether the data is read-only or read-write, see BLDataAccessFlags. destroyFunc A function that would be called when the array is destroyed (can be null if you don't need it). userData User data passed to destroyFunc.
template<typename T> template<typename... Args>BLResult BLArray<T>::append(Args&&... args)noexcept[¶]
Appends a variadic number of items items passed in args... to the array.
- Note
- The data in
argscannot point to the same data that the array holds as the function that prepares the append operation has no way to know about the source (it only makes space for new data). It's an undefined behavior in such case.
template<typename T>BLResult BLArray<T>::appendData(const BLArrayView<T>& view)noexcept[1/2][¶]
Appends items to the array of the given array view.
- Note
- The implementation guarantees that a
viewpointing to the array data itself would work.
template<typename T>BLResult BLArray<T>::appendData(const T* items, size_t n)noexcept[2/2][¶]
Appends items to the array of length n.
- Note
- The implementation guarantees that a
itemspointing to the array data itself would work.
template<typename T> template<typename... Args>BLResult BLArray<T>::prepend(Args&&... args)noexcept[¶]
Prepends a variadic number of items items passed in args... to the array.
- Note
- The data in
argscannot point to the same data that the array holds as the function that prepares the prepend operation has no way to know about the source (it only makes space for new data). It's an undefined behavior in such case.
template<typename T>BLResult BLArray<T>::prependData(const BLArrayView<T>& view)noexcept[1/2][¶]
Prepends items to the array of the given array view.
- Note
- The implementation guarantees that a
viewpointing to the array data itself would work.
template<typename T>BLResult BLArray<T>::prependData(const T* items, size_t n)noexcept[2/2][¶]
Prepends items to the array of length n.
- Note
- The implementation guarantees that a
itemspointing to the array data itself would work.
template<typename T> template<typename... Args>BLResult BLArray<T>::insert(size_t index, Args&&... args)noexcept[¶]
Inserts a variadic number of items items passed in args... at the given index.
- Note
- The data in
argscannot point to the same data that the array holds as the function that prepares the insert operation has no way to know about the source (it only makes space for new data). It's an undefined behavior in such case.
template<typename T>BLResult BLArray<T>::insertData(size_t index, const BLArrayView<T>& view)noexcept[1/2][¶]
Inserts items to the array of the given array view at the given index.
- Note
- The implementation guarantees that a
viewpointing to the array data itself would work.
template<typename T>BLResult BLArray<T>::insertData(size_t index, const T* items, size_t n)noexcept[2/2][¶]
Prepends items to the array of length n at the given index.
- Note
- The implementation guarantees that a
itemspointing to the array data itself would work.
template<typename T>BLResult BLArray<T>::replace(size_t index, const T& item)noexcept[¶]
Replaces an item at the given index by item.
template<typename T>BLResult BLArray<T>::replaceData(const BLRange& range, BLArrayView<T>& view)noexcept[1/2][¶]
Replaces the given range of items by the given array view.
template<typename T>BLResult BLArray<T>::replaceData(const BLRange& range, const T* items, size_t n)noexcept[2/2][¶]
Replaces the given range of items by items of length n.
template<typename T>BLResult BLArray<T>::remove(size_t index)noexcept[1/2][¶]
Removes an item at the given index.
template<typename T>BLResult BLArray<T>::remove(const BLRange& range)noexcept[2/2][¶]
Removes a range of items.
template<typename T>bool BLArray<T>::equals(const BLArray<T>& other) constnoexcept[¶]
Returns whether the content of this array and other matches.
template<typename T>size_t BLArray<T>::indexOf(const T& item) constnoexcept[1/2][¶]
Returns the first index at which a given item can be found in the array, or SIZE_MAX if not found.
template<typename T>size_t BLArray<T>::indexOf(const T& item, size_t fromIndex) constnoexcept[2/2][¶]
Returns the index at which a given item can be found in the array starting from fromIndex, or SIZE_MAX if not present.