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

Base classes

template<typename T>
class ObjList<T>

Public static functions

static auto calculateWorkBufferSize(size_t n) -> size_t constexpr

Constructors, destructors, conversion operators

FixedObjList()
__attribute__((always_inline))

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 isBufferReady() const -> bool
auto isFull() const -> bool
auto front() const -> T*
auto back() const -> T*
auto popBack() -> T
auto popFront() -> T
template<class... Args>
auto emplaceBack(Args && ... args) -> T*
void erase(T* item)
void clear()
auto prev(const T* obj) const -> T*
auto next(const T* obj) const -> T*
auto nth(s32 n) const -> T*
auto indexOf(const T* obj) const -> s32
auto isNodeLinked(const T* obj) const -> bool
auto begin() const -> iterator
auto begin(T* ptr) const -> iterator
auto end() const -> iterator
auto isEmpty() const -> bool
auto size() const -> s32
void reverse()
void shuffle()
void shuffle(Random* random)
auto checkLinks() const -> bool

Protected types

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

Protected static functions

template<class T, class ComparePredicate>
static void mergeSortImpl_(ListNode* front, ListNode* back, s32 num, s32 offset, const ComparePredicate& predicate)

Protected functions

void erase(ListNode* item)
auto nth(int n) const -> ListNode*
auto indexOf(const ListNode*) const -> s32
template<class T, class ComparePredicate>
void sort(s32 offset, const ComparePredicate& cmp)
template<class T, class ComparePredicate>
void mergeSort(s32 offset, const ComparePredicate& cmp)
void pushBack(ListNode* item)
void pushFront(ListNode* item)
void insertBefore(ListNode* node, ListNode* node_to_insert)
void insertAfter(ListNode* node, ListNode* node_to_insert)
void swap(ListNode* n1, ListNode* n2)
void moveAfter(ListNode* basis, ListNode* n)
void moveBefore(ListNode* basis, ListNode* n)
auto find(const void* ptr, s32 offset, CompareCallbackImpl cmp) const -> ListNode*
void uniq(s32 offset, CompareCallbackImpl cmp)

Protected variables

ListNode mStartEnd
s32 mCount

Typedef documentation

#include <container/seadListImpl.h>
template<typename T, s32 N>
using sead::FixedObjList<T, N>::CompareCallbackImpl = int(*)(const void*, const void*) protected

Function documentation

#include <container/seadListImpl.h>
template<typename T, s32 N>
sead::FixedObjList<T, N>::__attribute__((always_inline))

#include <container/seadListImpl.h>
template<typename T, s32 N>
bool sead::FixedObjList<T, N>::isEmpty() const

#include <container/seadListImpl.h>
template<typename T, s32 N>
s32 sead::FixedObjList<T, N>::size() const

#include <container/seadListImpl.h>
template<typename T, s32 N>
void sead::FixedObjList<T, N>::reverse()

#include <container/seadListImpl.h>
template<typename T, s32 N>
void sead::FixedObjList<T, N>::shuffle()

#include <container/seadListImpl.h>
template<typename T, s32 N>
void sead::FixedObjList<T, N>::shuffle(Random* random)

#include <container/seadListImpl.h>
template<typename T, s32 N>
bool sead::FixedObjList<T, N>::checkLinks() const

#include <container/seadListImpl.h>
template<typename T, s32 N> template<class T, class ComparePredicate>
static void sead::FixedObjList<T, N>::mergeSortImpl_(ListNode* front, ListNode* back, s32 num, s32 offset, const ComparePredicate& predicate) protected

#include <container/seadListImpl.h>
template<typename T, s32 N>
void sead::FixedObjList<T, N>::erase(ListNode* item) protected

#include <container/seadListImpl.h>
template<typename T, s32 N>
ListNode* sead::FixedObjList<T, N>::nth(int n) const protected

#include <container/seadListImpl.h>
template<typename T, s32 N>
s32 sead::FixedObjList<T, N>::indexOf(const ListNode*) const protected

#include <container/seadListImpl.h>
template<typename T, s32 N> template<class T, class ComparePredicate>
void sead::FixedObjList<T, N>::sort(s32 offset, const ComparePredicate& cmp) protected

#include <container/seadListImpl.h>
template<typename T, s32 N> template<class T, class ComparePredicate>
void sead::FixedObjList<T, N>::mergeSort(s32 offset, const ComparePredicate& cmp) protected

#include <container/seadListImpl.h>
template<typename T, s32 N>
void sead::FixedObjList<T, N>::pushBack(ListNode* item) protected

#include <container/seadListImpl.h>
template<typename T, s32 N>
void sead::FixedObjList<T, N>::pushFront(ListNode* item) protected

#include <container/seadListImpl.h>
template<typename T, s32 N>
void sead::FixedObjList<T, N>::insertBefore(ListNode* node, ListNode* node_to_insert) protected

#include <container/seadListImpl.h>
template<typename T, s32 N>
void sead::FixedObjList<T, N>::insertAfter(ListNode* node, ListNode* node_to_insert) protected

#include <container/seadListImpl.h>
template<typename T, s32 N>
void sead::FixedObjList<T, N>::swap(ListNode* n1, ListNode* n2) protected

#include <container/seadListImpl.h>
template<typename T, s32 N>
void sead::FixedObjList<T, N>::moveAfter(ListNode* basis, ListNode* n) protected

#include <container/seadListImpl.h>
template<typename T, s32 N>
void sead::FixedObjList<T, N>::moveBefore(ListNode* basis, ListNode* n) protected

#include <container/seadListImpl.h>
template<typename T, s32 N>
ListNode* sead::FixedObjList<T, N>::find(const void* ptr, s32 offset, CompareCallbackImpl cmp) const protected

#include <container/seadListImpl.h>
template<typename T, s32 N>
void sead::FixedObjList<T, N>::uniq(s32 offset, CompareCallbackImpl cmp) protected

Variable documentation

#include <container/seadListImpl.h>
template<typename T, s32 N>
ListNode sead::FixedObjList<T, N>::mStartEnd protected

#include <container/seadListImpl.h>
template<typename T, s32 N>
s32 sead::FixedObjList<T, N>::mCount protected