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

template<typename T>

sead::ObjArray class

Base classes

class PtrArrayImpl

Derived classes

template<typename T, s32 N>

class FixedObjArray

Public types

class constIterator

class iterator

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

ObjArray() defaulted

ObjArray(s32 max_num, void* buf)

Public functions

void allocBuffer(s32 capacity, Heap* heap, s32 alignment = sizeof(void*))

auto tryAllocBuffer(s32 capacity, Heap* heap, s32 alignment = sizeof(void*)) -> bool

void setBuffer(s32 max_num, void* buf)

void freeBuffer()

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 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 erase(s32 position)

void erase(s32 position, s32 count)

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

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

void pushBack(void* ptr)

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 equal(const PtrArrayImpl& other, CompareCallbackImpl cmp) const -> bool

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

void createVacancy(s32 pos, s32 count)

void insert(s32 idx, void* ptr)

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)

void heapSort(CompareCallbackImpl cmp)

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

void uniq(CompareCallbackImpl cmp)

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

Protected variables

sead::FreeList mFreeList

s32 mPtrNum

s32 mPtrNumMax

void** mPtrs

Typedef documentation

Function documentation

Variable documentation