mxlist.h

Go to the documentation of this file.

#ifndef MXLIST_H
#define MXLIST_H
 
#include "mxcollection.h"
#include "mxcore.h"
#include "mxtypes.h"
 
template <class T>
class MxList; // [AI] Used for type-safe linked list implementation.
 
template <class T>
class MxListCursor; // [AI] Iterator-like class for traversing/operating on MxList.
 
template <class T>
class MxListEntry {
public:
    MxListEntry() {}
 
    MxListEntry(T p_obj, MxListEntry* p_prev)
    {
        m_obj = p_obj;
        m_prev = p_prev;
        m_next = NULL;
    }
 
    MxListEntry(T p_obj, MxListEntry* p_prev, MxListEntry* p_next)
    {
        m_obj = p_obj;
        m_prev = p_prev;
        m_next = p_next;
    }
 
    T GetValue() { return this->m_obj; }
 
    MxListEntry* GetNext() { return m_next; }
 
    MxListEntry* GetPrev() { return m_prev; }
 
    void SetValue(T p_obj) { m_obj = p_obj; }
 
    void SetNext(MxListEntry* p_next) { m_next = p_next; }
 
    void SetPrev(MxListEntry* p_prev) { m_prev = p_prev; }
 
private:
    T m_obj;                
    MxListEntry* m_prev;    
    MxListEntry* m_next;    
};
 
// SIZE 0x18
template <class T>
class MxList : protected MxCollection<T> {
public:
    MxList() { m_first = m_last = NULL; }
 
    ~MxList() override { DeleteAll(); }
 
    void Append(T p_obj) { InsertEntry(p_obj, this->m_last, NULL); }
 
    void Prepend(T p_obj) { InsertEntry(p_obj, NULL, this->m_first); }
 
    void DeleteAll();
 
    void Empty();
 
    MxU32 GetNumElements() { return this->m_count; }
 
    friend class MxListCursor<T>;
    using MxCollection<T>::SetDestroy;
 
protected:
    MxListEntry<T>* m_first; 
    MxListEntry<T>* m_last;  
 
    void DeleteEntry(MxListEntry<T>*);
 
    MxListEntry<T>* InsertEntry(T, MxListEntry<T>*, MxListEntry<T>*);
};
 
// SIZE 0x18
template <class T>
class MxPtrList : public MxList<T*> {
public:
    MxPtrList(MxBool p_ownership) { SetOwnership(p_ownership); }
 
    static void Destroy(T* p_obj) { delete p_obj; }
 
    void SetOwnership(MxBool p_ownership)
    {
        MxCollection<T*>::SetDestroy(p_ownership ? MxPtrList<T>::Destroy : MxCollection<T*>::Destroy);
    }
};
 
// SIZE 0x10
template <class T>
class MxListCursor : public MxCore {
public:
    MxListCursor(MxList<T>* p_list)
    {
        m_list = p_list;
        m_match = NULL;
    }
 
    MxBool Find(T p_obj);
 
    void Detach();
 
    void Destroy();
 
    MxBool Next();
 
    MxBool Next(T& p_obj);
 
    MxBool Prev();
 
    MxBool Prev(T& p_obj);
 
    MxBool Current(T& p_obj);
 
    MxBool First(T& p_obj);
 
    MxBool Last(T& p_obj);
 
    MxBool HasMatch() { return m_match != NULL; }
 
    void SetValue(T p_obj);
 
    MxBool Head()
    {
        m_match = m_list->m_first;
        return m_match != NULL;
    }
 
    MxBool Tail()
    {
        m_match = m_list->m_last;
        return m_match != NULL;
    }
 
    void Reset() { m_match = NULL; }
 
    void Prepend(T p_newobj);
 
private:
    MxList<T>* m_list;           
    MxListEntry<T>* m_match;     
};
 
// SIZE 0x10
template <class T>
class MxPtrListCursor : public MxListCursor<T*> {
public:
    MxPtrListCursor(MxPtrList<T>* p_list) : MxListCursor<T*>(p_list) {}
};
 
#endif // MXLIST_H