tb_linklist.h

// ================================================================================
// ==      This file is a part of Turbo Badger. (C) 2011-2014, Emil Segerås      ==
// ==                     See tb_core.h for more information.                    ==
// ================================================================================

#ifndef TB_LINKLIST_H
#define TB_LINKLIST_H

#include "tb_core.h"
#include <assert.h>

namespace tb {

class TBLinkList;
class TBLink;

class TBLinkListIterator
{
public:
    TBLinkListIterator(const TBLinkListIterator &iter);
    TBLinkListIterator(TBLinkList *linklist, TBLink *current_link, bool forward);
    ~TBLinkListIterator();

    void Reset();

    TBLink *Get() const { return m_current_link; }

    TBLink *GetAndStep();

    operator TBLink *() const { return m_current_link; }

    const TBLinkListIterator& operator = (const TBLinkListIterator &iter);
private:
    TBLinkList *m_linklist;         
    TBLink *m_current_link;         
    bool m_forward;                 

    TBLinkListIterator *m_prev;     
    TBLinkListIterator *m_next;     

    void RemoveLink(TBLink *link);
    friend class TBLinkList;

    void Register();

    void Unregister();
    void UnregisterAndClear();
};

class TBLink
{
public:
    TBLink() : prev(nullptr), next(nullptr), linklist(nullptr) {}

    bool IsInList() const { return linklist ? true : false; }
public:
    TBLink *prev;
    TBLink *next;
    TBLinkList *linklist;
};

template<class T>
class TBLinkOf : public TBLink
{
public:
    inline T *GetPrev() const { return (T *) prev; }
    inline T *GetNext() const { return (T *) next; }
};

class TBLinkList
{
public:
    TBLinkList() : first(nullptr), last(nullptr), first_iterator(nullptr) {}
    ~TBLinkList();

    void Remove(TBLink *link);
    void RemoveAll();

    void AddFirst(TBLink *link);
    void AddLast(TBLink *link);

    void AddBefore(TBLink *link, TBLink *reference);
    void AddAfter(TBLink *link, TBLink *reference);

    bool ContainsLink(TBLink *link) const { return link->linklist == this; }

    bool HasLinks() const { return first ? true : false; }

    int CountLinks() const;
public:
    TBLink *first;
    TBLink *last;
    TBLinkListIterator *first_iterator;
};

template<class T>
class TBLinkListOf
{
public:
    void Remove(T *link)            { m_linklist.Remove(static_cast<TBLinkOf<T>*>(link)); }

    void Delete(T *link)            { m_linklist.Remove(static_cast<TBLinkOf<T>*>(link)); delete link; }

    void RemoveAll()                { m_linklist.RemoveAll(); }

    void DeleteAll()                { while (T *t = GetFirst()) Delete(t); }

    void AddFirst(T *link)          { m_linklist.AddFirst(static_cast<TBLinkOf<T>*>(link)); }

    void AddLast(T *link)           { m_linklist.AddLast(static_cast<TBLinkOf<T>*>(link)); }

    void AddBefore(T *link, T *reference) { m_linklist.AddBefore(static_cast<TBLinkOf<T>*>(link), reference); }

    void AddAfter(T *link, T *reference) { m_linklist.AddAfter(static_cast<TBLinkOf<T>*>(link), reference); }

    bool ContainsLink(T *link) const { return m_linklist.ContainsLink(static_cast<TBLinkOf<T>*>(link)); }

    T *GetFirst() const { return (T *) static_cast<TBLinkOf<T>*>(m_linklist.first); }

    T *GetLast() const { return (T *) static_cast<TBLinkOf<T>*>(m_linklist.last); }

    bool HasLinks() const { return m_linklist.HasLinks(); }

    int CountLinks() const { return m_linklist.CountLinks(); }

    class Iterator : public TBLinkListIterator
    {
    public:
        Iterator(TBLinkListOf<T> *linklistof, bool forward)
            : TBLinkListIterator(&linklistof->m_linklist, forward ? linklistof->m_linklist.first : linklistof->m_linklist.last, forward) {}
        Iterator(TBLinkListOf<T> *linklistof, T *link, bool forward) : TBLinkListIterator(&linklistof->m_linklist, link, forward) {}
        inline T *Get() const { return (T *) static_cast<TBLinkOf<T>*>(TBLinkListIterator::Get()); }
        inline T *GetAndStep() { return (T *) static_cast<TBLinkOf<T>*>(TBLinkListIterator::GetAndStep()); }
        inline operator T *() const { return (T *) static_cast<TBLinkOf<T>*>(Get()); }
    };

    Iterator IterateForward() { return Iterator(this, true); }

    Iterator IterateForward(T *link) { return Iterator(this, link, true); }

    Iterator IterateBackward() { return Iterator(this, false); }

    Iterator IterateBackward(T *link) { return Iterator(this, link, false); }
private:
    TBLinkList m_linklist;
};

template<class T>
class TBLinkListAutoDeleteOf : public TBLinkListOf<T>
{
public:
    ~TBLinkListAutoDeleteOf() { TBLinkListOf<T>::DeleteAll(); }
};

} // namespace tb

#endif // TB_LINKLIST_H