#include </OdysseyDecomp/lib/sead/include/container/seadObjArray.h>

template<typename T, s32 N>

sead::FixedObjArray class

Base classes

template<typename T>

class ObjArray<T>

Public types

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

Public static variables

static size_t ElementSize constexpr

Public static functions

static auto calculateWorkBufferSize(size_t n) -> size_t constexpr

Constructors, destructors, conversion operators

FixedObjArray()

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(const T& item)

template<class... Args>

auto emplaceBack(Args && ... args) -> T*

void insert(s32 pos, const T& item)

void erase(int index)

void erase(int index, int count)

void erase(s32 position)

void erase(s32 position, s32 count)

void clear()

void sort()

void sort(CompareCallback cmp)

void heapSort()

void heapSort(CompareCallback cmp)

auto equal(const ObjArray& other, CompareCallback cmp) const -> bool

auto compare(const ObjArray& other, CompareCallback cmp) const -> s32

auto binarySearch(const T* ptr) const -> s32

auto binarySearch(const T* ptr, CompareCallback cmp) const -> s32

auto operator==(const ObjArray& other) const -> bool

auto operator!=(const ObjArray& other) const -> bool

auto operator<(const ObjArray& other) const -> bool

auto operator<=(const ObjArray& other) const -> bool

auto operator>(const ObjArray& other) const -> bool

auto operator>=(const ObjArray& 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 isBufferReady() const -> bool

auto isEmpty() const -> bool

auto isFull() const -> bool

auto size() const -> s32

auto capacity() const -> s32

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 compareT(const void* a_, const void* b_) -> int

Protected functions

void pushBack(void* ptr)

void insert(s32 idx, void* ptr)

void heapSort(CompareCallbackImpl cmp)

auto equal(const PtrArrayImpl& other, CompareCallbackImpl cmp) const -> bool

auto compare(const PtrArrayImpl& other, CompareCallbackImpl cmp) const -> s32

auto binarySearch(const void* ptr, CompareCallbackImpl cmp) const -> s32

void uniq(CompareCallbackImpl cmp)

auto alloc(const T& item) -> T*

void pushFront(void* ptr)

auto popBack() -> void*

auto popFront() -> void*

void replace(s32 idx, void* ptr)

auto find(const void* ptr, CompareCallbackImpl cmp) const -> void*

auto search(const void* ptr, CompareCallbackImpl cmp) const -> s32

auto indexOf(const void* ptr) const -> s32

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

sead::FreeList mFreeList

s32 mPtrNum

s32 mPtrNumMax

void** mPtrs

Typedef documentation

Function documentation

Variable documentation