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

template<typename T>

sead::OffsetList class

Base classes

class ListImpl

Public types

class iterator

class robustIterator

struct RobustRange

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

Constructors, destructors, conversion operators

OffsetList() defaulted

__attribute__((always_inline))

Public functions

void initOffset(s32 offset)

void clear()

void pushBack(T* item)

void pushFront(T* item)

auto popBack() -> T*

auto popFront() -> T*

void insertBefore(const T* obj, T* obj_to_insert)

void insertAfter(const T* obj, T* obj_to_insert)

void erase(T* item)

auto front() const -> T*

auto back() const -> T*

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

void swap(T* obj1, T* obj2)

void moveAfter(T* basis, T* obj)

void moveBefore(T* basis, T* obj)

void sort()

void sort(CompareCallback cmp)

void mergeSort()

void mergeSort(CompareCallback cmp)

auto find(const T* obj) const -> T*

auto find(const T* obj, CompareCallback cmp) const -> T*

void uniq()

void uniq(CompareCallback cmp)

auto begin() const -> iterator

auto end() const -> iterator

auto begin(T* ptr) const -> iterator

auto robustBegin() const -> robustIterator

auto robustEnd() const -> robustIterator

auto robustBegin(T* ptr) const -> robustIterator

auto robustRange() const -> RobustRange

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

static auto compareT(const T* lhs, const T* rhs) -> int

template<class T, class ComparePredicate>

static void mergeSortImpl_(ListNode* front, ListNode* back, s32 num, s32 offset, const ComparePredicate& predicate)

Protected functions

auto objToListNode(T* obj) const -> ListNode*

auto objToListNode(const T* obj) const -> const ListNode*

auto listNodeToObj(ListNode* node) const -> T*

auto listNodeToObj(const ListNode* node) const -> const T*

auto listNodeToObjWithNullCheck(ListNode* node) const -> T*

auto listNodeToObjWithNullCheck(const ListNode* node) const -> const T*

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 erase(ListNode* item)

auto nth(int n) const -> ListNode*

auto indexOf(const ListNode*) const -> s32

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

s32 mOffset

ListNode mStartEnd

s32 mCount

Typedef documentation

Function documentation

Variable documentation