ll.h

Go to the documentation of this file.

/*===========================================================================
     _____        _____        _____        _____
 ___|    _|__  __|_    |__  __|__   |__  __| __  |__  ______
|    \  /  | ||    \      ||     |     ||  |/ /     ||___   |
|     \/   | ||     \     ||     \     ||     \     ||___   |
|__/\__/|__|_||__|\__\  __||__|\__\  __||__|\__\  __||______|
    |_____|      |_____|      |_____|      |_____|

--[Mark3 Realtime Platform]--------------------------------------------------

Copyright (c) 2012 - 2019 m0slevin, all rights reserved.
See license.txt for more information
=========================================================================== */
#pragma once
#include "kerneltypes.h"

namespace Mark3
{
//---------------------------------------------------------------------------
class LinkList;
class DoubleLinkList;
class CircularLinkList;

//---------------------------------------------------------------------------
class LinkListNode
{
protected:
    LinkListNode* next; 
    LinkListNode* prev; 

    LinkListNode() {}

    void ClearNode();

public:
    LinkListNode* GetNext(void) { return next; }
    LinkListNode* GetPrev(void) { return prev; }
    friend class LinkList;
    friend class DoubleLinkList;
    friend class CircularLinkList;
};

//---------------------------------------------------------------------------
template <typename T>
class TypedLinkListNode : public LinkListNode
{
public:
    T* GetNext() { return static_cast<T*>(LinkListNode::GetNext()); }
    T* GetPrev() { return static_cast<T*>(LinkListNode::GetPrev()); }
};
//---------------------------------------------------------------------------
class LinkList
{
protected:
    LinkListNode* m_pclHead; 
    LinkListNode* m_pclTail; 

public:
    void Init()
    {
        m_pclHead = nullptr;
        m_pclTail = nullptr;
    }

    LinkListNode* GetHead() { return m_pclHead; }

    void SetHead(LinkListNode* pclNode_) { m_pclHead = pclNode_; }

    LinkListNode* GetTail() { return m_pclTail; }

    void SetTail(LinkListNode* pclNode_) { m_pclTail = pclNode_; }
};

//---------------------------------------------------------------------------
class DoubleLinkList : public LinkList
{
public:
    void* operator new(size_t sz, void* pv) { return reinterpret_cast<DoubleLinkList*>(pv); };
    DoubleLinkList()
    {
        m_pclHead = nullptr;
        m_pclTail = nullptr;
    }

    void Add(LinkListNode* node_);

    void Remove(LinkListNode* node_);
};

//---------------------------------------------------------------------------
class CircularLinkList : public LinkList
{
public:
    void* operator new(size_t sz, void* pv) { return (CircularLinkList*)pv; };
    CircularLinkList()
    {
        m_pclHead = nullptr;
        m_pclTail = nullptr;
    }

    void Add(LinkListNode* node_);

    void Remove(LinkListNode* node_);

    void PivotForward();

    void PivotBackward();

    void InsertNodeBefore(LinkListNode* node_, LinkListNode* insert_);
};

//---------------------------------------------------------------------------
template <typename T>
class TypedDoubleLinkList : public DoubleLinkList
{
public:
    void* operator new(size_t sz, void* pv) { return reinterpret_cast<TypedDoubleLinkList<T>*>(pv); }

    TypedDoubleLinkList<T>() {
        DoubleLinkList::Init();
    }

    T* GetHead() { return static_cast<T*>(DoubleLinkList::GetHead()); }

    void SetHead(T* pclNode_) { DoubleLinkList::SetHead(pclNode_); }

    T* GetTail() { return static_cast<T*>(DoubleLinkList::GetTail()); }

    void SetTail(T* pclNode_) { DoubleLinkList::SetTail(pclNode_); }

    void Add(T* pNode_)
    {
        DoubleLinkList::Add(pNode_);
    }

    void Remove(T* pNode_)
    {
        DoubleLinkList::Remove(pNode_);
    }
};

//---------------------------------------------------------------------------
template <typename T>
class TypedCircularLinkList : public CircularLinkList
{
public:
    void* operator new(size_t sz, void* pv) { return reinterpret_cast<TypedCircularLinkList<T>*>(pv); }

    TypedCircularLinkList<T>() {
        CircularLinkList::Init();
    }

    T* GetHead() { return static_cast<T*>(CircularLinkList::GetHead()); }

    void SetHead(T* pclNode_) { CircularLinkList::SetHead(pclNode_); }

    T* GetTail() { return static_cast<T*>(CircularLinkList::GetTail()); }

    void SetTail(T* pclNode_) { CircularLinkList::SetTail(pclNode_); }

    void Add(T* pNode_)
    {
        CircularLinkList::Add(pNode_);
    }

    void Remove(T* pNode_)
    {
        CircularLinkList::Remove(pNode_);
    }

    void InsertNodeBefore(T* pNode_, T* pInsert_)
    {
        CircularLinkList::InsertNodeBefore(pNode_, pInsert_);
    }
};
} // namespace Mark3