seadListImpl.h

Go to the documentation of this file.

#ifndef SEAD_LIST_IMPL_H_
#define SEAD_LIST_IMPL_H_
 
#include <random/seadRandom.h>
 
namespace sead {
 
class Random;
 
class ListNode
{
public:
    ListNode()
        : mPrev(nullptr)
        , mNext(nullptr)
    {
    }
 
private:
    ListNode(const ListNode&);
    const ListNode& operator=(const ListNode&);
 
public:
    ListNode* next() const { return mNext; }
    ListNode* prev() const { return mPrev; }
 
    bool isLinked() const { return mNext || mPrev; }
 
private:
    void init_()
    {
        mNext = nullptr;
        mPrev = nullptr;
    }
 
    void insertBack_(ListNode* n);
    void insertFront_(ListNode* n);
    void erase_();
 
private:
    ListNode* mPrev;
    ListNode* mNext;
 
    friend class ListImpl;
};
#ifdef cafe
static_assert(sizeof(ListNode) == 0x8, "sead::ListNode size mismatch");
#endif // cafe
 
class ListImpl
{
protected:
    using CompareCallbackImpl = s32 (*)(const void* a, const void* b);
 
public:
    ListImpl()
        : mStartEnd()
        , mCount(0)
    {
        mStartEnd.mNext = &mStartEnd;
        mStartEnd.mPrev = &mStartEnd;
    }
 
protected:
    ListImpl(const ListImpl&);
 
public:
    bool isEmpty() const { return mCount == 0; }
 
    s32 size() const { return mCount; }
 
    void reverse();
 
    void shuffle()
    {
        Random random;
        shuffle(&random);
    }
 
    void shuffle(Random* random);
    bool checkLinks() const;
 
protected:
    void sort(s32 offset, CompareCallbackImpl cmp);
    void mergeSort(s32 offset, CompareCallbackImpl cmp);
 
    void pushBack(ListNode* n)
    {
        mStartEnd.insertFront_(n);
        mCount += 1;
    }
 
    void pushFront(ListNode* n)
    {
        mStartEnd.insertBack_(n);
        mCount += 1;
    }
 
    ListNode* popBack();
    ListNode* popFront();
 
    void insertBefore(ListNode* basis, ListNode* n)
    {
        basis->insertFront_(n);
        mCount += 1;
    }
 
    void insertAfter(ListNode* basis, ListNode* n)
    {
        basis->insertBack_(n);
        mCount += 1;
    }
 
    void erase(ListNode* n)
    {
        n->erase_();
        mCount -= 1;
    }
 
    ListNode* front() const { return mCount > 0 ? mStartEnd.mNext : nullptr; }
    ListNode* back() const { return mCount > 0 ? mStartEnd.mPrev : nullptr; }
 
    ListNode* nth(s32 index) const;
    s32 indexOf(const ListNode* n) const;
 
    void swap(ListNode* n1, ListNode* n2);
    void moveAfter(ListNode* basis, ListNode* n);
    void moveBefore(ListNode* basis, ListNode* n);
 
    ListNode* find(const void* ptr, s32 offset, CompareCallbackImpl cmp) const;
    void uniq(s32 offset, CompareCallbackImpl cmp);
 
    void clear();
 
    void unsafeClear()
    {
        mCount = 0;
        mStartEnd.mPrev = &mStartEnd;
        mStartEnd.mNext = &mStartEnd;
    }
 
    static void mergeSortImpl(ListNode* front, ListNode* back, s32 num, s32 offset, CompareCallbackImpl cmp);
    ListImpl& operator=(const ListImpl&);
 
protected:
    ListNode mStartEnd;
    s32 mCount;
};
#ifdef cafe
static_assert(sizeof(ListImpl) == 0xC, "sead::ListImpl size mismatch");
#endif // cafe
 
} // namespace sead
 
#endif // SEAD_LIST_IMPL_H_