#include </OdysseyDecomp/lib/sead/include/container/seadPtrArray.h>
template<typename T, s32 N>
sead::FixedPtrArray class

Base classes

template<typename T>
class PtrArray<T>

Public types

using CompareCallback = s32(*)(const T*, const T*)

Constructors, destructors, conversion operators

FixedPtrArray()

Public functions

void setBuffer(s32 ptrNumMax, void* buf) deleted
void allocBuffer(s32 ptrNumMax, Heap* heap, s32 alignment = sizeof(void*)) deleted
auto tryAllocBuffer(s32 ptrNumMax, Heap* heap, s32 alignment = sizeof(void*)) -> bool deleted
void freeBuffer() deleted
auto at(s32 pos) const -> T*
auto unsafeAt(s32 pos) const -> T*
auto operator()(s32 pos) const -> T*
auto operator[](s32 pos) const -> T*
auto front() const -> T*
auto back() const -> T*
void pushBack(T* ptr)
void pushFront(T* ptr)
auto popBack() -> T*
auto popFront() -> T*
void insert(s32 pos, T* ptr)
void insert(s32 pos, T* array, s32 count)
void replace(s32 pos, T* ptr)
auto indexOf(const T* ptr) const -> s32
void sort()
void sort(CompareCallback cmp)
void heapSort()
void heapSort(CompareCallback cmp)
auto equal(const PtrArray& other, CompareCallback cmp) const -> bool
auto compare(const PtrArray& other, CompareCallback cmp) const -> s32
auto find(const T* ptr) const -> T*
auto find(const T* ptr, CompareCallback cmp) const -> T*
auto search(const T* ptr) const -> s32
auto search(const T* ptr, CompareCallback cmp) const -> s32
auto binarySearch(const T* ptr) const -> s32
auto binarySearch(const T* ptr, CompareCallback cmp) const -> s32
auto operator==(const PtrArray& other) const -> bool
auto operator!=(const PtrArray& other) const -> bool
auto operator<(const PtrArray& other) const -> bool
auto operator<=(const PtrArray& other) const -> bool
auto operator>(const PtrArray& other) const -> bool
auto operator>=(const PtrArray& other) const -> bool
void uniq()
void uniq(CompareCallback cmp)
auto begin() const -> iterator
auto end() const -> iterator
auto constBegin() const -> constIterator
auto constEnd() const -> constIterator
auto data() const -> T**
auto dataBegin() const -> T**
auto dataEnd() const -> T**
auto isBufferReady() const -> bool
auto isEmpty() const -> bool
auto isFull() const -> bool
auto size() const -> s32
auto capacity() const -> s32
void erase(s32 position)
void erase(s32 position, s32 count)
void clear()
void resize(s32 size)
void unsafeResize(s32 size)
void swap(s32 pos1, s32 pos2)
void reverse()
void shuffle()
void shuffle(Random* random)

Protected types

using CompareCallbackImpl = int(*)(const void*a, const void*b)

Protected static functions

static auto constCast(const T* ptr) -> void*
static auto compareT(const void* a_, const void* b_) -> int

Protected functions

void pushBack(void* ptr)
void pushFront(void* ptr)
void insert(s32 idx, void* ptr)
void replace(s32 idx, void* ptr)
auto indexOf(const void* ptr) const -> s32
void heapSort(CompareCallbackImpl cmp)
auto equal(const PtrArrayImpl& other, CompareCallbackImpl cmp) const -> bool
auto compare(const PtrArrayImpl& other, CompareCallbackImpl cmp) const -> s32
auto find(const void* ptr, CompareCallbackImpl cmp) const -> void*
auto search(const void* ptr, CompareCallbackImpl cmp) const -> s32
auto binarySearch(const void* ptr, CompareCallbackImpl cmp) const -> s32
void uniq(CompareCallbackImpl cmp)
void createVacancy(s32 pos, s32 count)
void insertArray(s32 idx, void* array, s32 array_length, s32 elem_size)
auto checkInsert(s32 idx, s32 num) -> bool
template<typename T, typename Compare>
void sort_(Compare cmp)
template<typename T, typename Compare>
void heapSort_(Compare cmp)

Protected variables

s32 mPtrNum
s32 mPtrNumMax
void** mPtrs