Amiga ISO Collection/AmigaUtilCD2.iso/Programming/C/OTL-MC7.DMS/in.adf/classsource.lha/ClassSource/Exec/Lists/Lists.c

C/C++ Source or Header | 1995-02-12 | 4.9 KB | 346 lines

#include <classes/Exec/Lists.h>

#include <pragma/exec_lib.h>

NodeC::NodeC()
{
    mln_Succ = NULL;
    mln_Pred = NULL;
}

NodeC::NodeC(const NodeC &)
{
    mln_Succ = NULL;
    mln_Pred = NULL;
}

NodeC::~NodeC()
{
    remove();
}

NodeC &NodeC::operator = (const NodeC &s)
{
    if (this != &s)
    {
        mln_Succ = NULL;
        mln_Pred = NULL;
    };
    return *this;
}

VOID NodeC::remove()
{
    if (isInList())
    {
        Remove((struct Node *) this);
        mln_Succ = NULL;
        mln_Pred = NULL;
    };
}

ULONG NodeC::index() const
{
    if (isInList())
    {
        ULONG i = 0;
        struct MinNode *n = (struct MinNode *) this;
        while (n = n->mln_Pred)
            i++;
        return i;
    };
    return 0;
}

NodeC *NodeC::next() const
{
    if (mln_Succ->mln_Succ == NULL)
        return NULL;
    return (NodeC *) mln_Succ;
}

NodeC *NodeC::prev() const
{
    if (mln_Pred->mln_Pred == NULL)
        return NULL;
    return (NodeC *) mln_Pred;
}

// **********************************************************

ListC::ListC()
{
    newList();
}

ListC::ListC(const ListC &s)
{
    newList();
}

ListC::~ListC()
{
    NodeC *n;
    while (n = remHead()) {
        n->mln_Succ = NULL;
        n->mln_Pred = NULL;
    };
}

ListC &ListC::operator = (const ListC &s)
{
    if (this != &s)
    {
        NodeC *n;
        while (n = (NodeC *) remHead()) {
            n->mln_Succ = NULL;
            n->mln_Pred = NULL;
        };
    };
    return *this;
}

VOID ListC::insert(NodeC &node, NodeC *after)
{
    if (!node.isInList())
        Insert((struct List *) this,
            (struct Node *) &node,(struct Node *) after);
}

VOID ListC::addHead(NodeC &node)
{
    if (!node.isInList())
        AddHead((struct List *) this,(struct Node *) &node);
}

VOID ListC::addTail(NodeC &node)
{
    if (!node.isInList())
        AddTail((struct List *) this,(struct Node *) &node);
}

NodeC *ListC::remHead()
{
    NodeC *n = (NodeC *) RemHead((struct List *) this);
    if (n)
    {
        n->mln_Succ = NULL;
        n->mln_Pred = NULL;
    };
    return n;
}

NodeC *ListC::remTail()
{
    NodeC *n = (NodeC *) RemTail((struct List *) this);
    if (n)
    {
        n->mln_Succ = NULL;
        n->mln_Pred = NULL;
    };
    return n;
}

ULONG ListC::indexOf(const NodeC &node) const
{
    NodeC *n = (NodeC *) mlh_Head;
    ULONG i = 1;
    while (n->mln_Succ)
    {
        if (n == &node)
            return i;
        i++;
        n = (NodeC *) n->mln_Succ;
    };
    return 0;
}

ULONG ListC::length() const
{
    ULONG i = 0;
    ListCursorC lc((ListC &) *this);
    while (!lc.isDone())
    {
        i++;
        lc.next();
    };
    return i;
}

NodeC *ListC::find(ULONG index) const
{
    ListCursorC lc((ListC &) *this);
    while (!lc.isDone())
    {
        if (index == 0)
            return lc.item();
        index--;
        lc.next();
    };
    return NULL;
}

NodeC *ListC::first() const
{
    if (mlh_Head->mln_Succ == NULL)
        return NULL;
    return (NodeC *) mlh_Head;
}

NodeC *ListC::last() const
{
    if (mlh_TailPred->mln_Pred == NULL)
        return NULL;
    return (NodeC *) mlh_TailPred;
}

// **************************************************************

ListCursorC::ListCursorC(const ListC &l)
{
    list = (ListC *) &l;
    first();
}

ListCursorC::ListCursorC(const ListCursorC &s)
{
    list = s.list;
    first();
}

ListCursorC &ListCursorC::operator = (const ListCursorC &s)
{
    if (this != &s)
    {
        list = s.list;
        pos = s.pos;
    };
    return *this;
}

VOID ListCursorC::first()
{
    pos = list->isEmpty() ? NULL : (NodeC *) list->mlh_Head;
}

VOID ListCursorC::last()
{
    pos = list->isEmpty() ? NULL : (NodeC *) list->mlh_TailPred;
}

VOID ListCursorC::next()
{
    if (pos)
        if (pos->mln_Succ)
            pos = (NodeC *) pos->mln_Succ;
}

VOID ListCursorC::prev()
{
    if (pos)
        if (pos->mln_Pred)
            pos = (NodeC *) pos->mln_Pred;
}

NodeC *ListCursorC::item() const
{
    return isDone() ? NULL : pos;
}

BOOL ListCursorC::isDone() const
{
    if (pos)
        if ((pos->mln_Succ != NULL) && (pos->mln_Pred != NULL))
            return FALSE;
    return TRUE;
}

// *************************************************************

ENodeC::ENodeC(STRPTR name, UBYTE type, BYTE pri)
    : NodeC()
{
    ln_Type = type;
    ln_Pri = pri;
    ln_Name = name;
}

ENodeC::ENodeC(const ENodeC &s)
    : NodeC()
{
    ln_Type = s.ln_Type;
    ln_Pri = s.ln_Pri;
    ln_Name = s.ln_Name;
}

ENodeC::~ENodeC()
{
}

ENodeC &ENodeC::operator= (const ENodeC &s)
{
    if (this != &s)
    {
        NodeC::operator=(s);
        ln_Type = s.ln_Type;
        ln_Pri = s.ln_Pri;
        ln_Name = s.ln_Name;
    };
    return *this;
}

ENodeC *ENodeC::find(STRPTR name) const
{
    return (ENodeC *) FindName((struct List *) this,name);
}

// **********************************************************

EListC::EListC(UBYTE type)
    : ListC()
{
    lh_Type = type;
}

EListC::EListC(const EListC &s)
    : ListC()
{
    lh_Type = s.lh_Type;
}

EListC::~EListC()
{
}

EListC &EListC::operator= (const EListC &s)
{
    if (this != &s)
    {
        ListC::operator=(s);
        lh_Type = s.lh_Type;
    };
    return *this;
}

VOID EListC::enqueue(ENodeC &node)
{
    Enqueue((struct List *) this,(struct Node *) &node);
}

ENodeC *EListC::find(STRPTR name) const
{
    return (ENodeC *) FindName((struct List *) this,name);
}

// **************************************************************

EListCursorC &EListCursorC::operator = (const EListCursorC &s)
{
    if (this != &s)
    {
        ListCursorC::operator=(s);
    };
    return *this;
}