ListIn.hpp

Go to the documentation of this file.

#ifndef LISTIN_HPP
#define LISTIN_HPP

#include "ListIn.h"

/******************************************************************************************
Implementation

Note that when we need to convert a List or Node pointer/reference to a ListInRoot/ListInNode
pointer/reference we need to do an explicit static_cast, to avoid ambiquity in the case of
classes deriving from multiple versions of ListInRoot/ListInNode
*/

template <class R, class N, int n> inline void ListInNode<R, N, n>::remove() {
    if (root_) {
        Root* mylist = static_cast<Root*>(root_);
        // We are on a list, are we the first node?
        if (mylist->first_ == this) {
            // Yes, point root to next node in list (if any), and disconnect us.
            mylist->first_ = next_;
            next_ = 0;
            root_ = 0;
        } else {
            // We aren't the first, so find the node before us.
            N* node = mylist->first_;

            while (node != 0) {
                Node* mynode = static_cast<Node*>(node);
                N* next = mynode->next_;
                if (next == this) {
                    // Found our predecessor, unlink
                    mynode->next_ = next_;
                    next_ = 0;
                    root_ = 0;
                    break;
                }
                node = mynode->next_;
                // we could assert node here, as we should be able to find ourselves on the list
            }
        }
    }
}


template <class R, class N, int n_> inline void ListInRoot<R, N, n_>::remove(N& node) {
    Node& mynode = static_cast<Node&>(node);
    if (mynode.root_ == this) {
        // Only remove if node is on this list.
        mynode.remove();
    }
}


template <class R, class N, int n_> inline void ListInRoot<R, N, n_>::remove(N* node) {
    if (node != 0) remove(*node);
}

template<class R, class N, int n_> inline void ListInRoot<R, N, n_>::addFirst(N& node) {
    Node& mynode = static_cast<Node&>(node);

    if (mynode.root_ != 0) mynode.remove();
    mynode.root_ = static_cast<R*>(this);
    mynode.next_ = first_;
    first_ = &node;
}

template<class R, class N, int n_> inline void ListInRoot<R, N, n_>::addFirst(N* node) {
    if (node != 0) addFirst(*node);
}

template<class R, class N, int n_> inline void ListInRoot<R, N, n_>::addLast(N& node) {
    Node& mynode = static_cast<Node&>(node);

    if (mynode.root_ != 0) mynode.remove();

    if (first_ == 0) {
        first_ = &node;
    } else {
        N* scannode = first_;
        N* nextnode;
        while (nextnode = static_cast<Node*>(scannode)->next_) {
            scannode = nextnode;
        }
        static_cast<Node*>(scannode)->next_ = &node;
    }
    mynode.root_ = static_cast<R*>(this);
    mynode.next_ = 0;
}

template<class R, class N, int n_> inline void ListInRoot<R, N, n_>::addLast(N* node) {
    if (node != 0) addLast(*node);
}



template<class R, class N, int n_> inline void ListInRoot<R, N, n_>::add(N& node) {
    addFirst(node);
}


template<class R, class N, int n_> inline void ListInRoot<R, N, n_>::add(N* node) {
    if (node != 0) add(*node);
}

template<class R, class N, int n> inline void ListInNode<R, N, n>::addToFront(R& root) {
    static_cast<Root&>(root).addFirst(*static_cast<N*>(this));
}

template<class R, class N, int n> inline void ListInNode<R, N, n>::addToFront(R* root) {
    if (root) {
        static_cast<Root*>(root)->addFirst(*static_cast<N*>(this));
    } else {
        remove();
    }
}

template<class R, class N, int n> inline void ListInNode<R, N, n>::addToEnd(R& root) {
    static_cast<Root&>(root).addLast(*static_cast<N*>(this));
}


template<class R, class N, int n> inline void ListInNode<R, N, n>::addToEnd(R* root) {
    if (root) {
        static_cast<Root*>(root)->addLast(*static_cast<N*>(this));
    } else {
        remove();
    }
}

template<class R, class N, int n> inline void ListInNode<R, N, n>::addAfter(N& node) {
    Node &mynode = static_cast<Node&>(node);
    N* me = static_cast<N*>(this);
    if (mynode.root_ && &node != me) {
        remove();
        root_ = mynode.root_;
        next_ = mynode.next_;
        mynode.next_ = me;
    }
}

template<class R, class N, int n> inline void ListInNode<R, N, n>::addAfter(N* node) {
    if (node != 0) {
        addAfter(*node);
    }
}

template<class R, class N, int n> void ListInNode<R, N, n>::addTo(R& root) {
    addToFront(root);
}

template<class R, class N, int n> void ListInNode<R, N, n>::addTo(R* root) {
    addToFront(root);
}


template <class R, class N, int n> ListInRoot<R, N, n>::ListInRoot() :
first_(0) {}

template <class R, class N, int n> ListInRoot<R, N, n>::~ListInRoot() {
    while (first_) remove(first_);
}

template <class R, class N, int n> ListInNode<R, N, n>::ListInNode(R* root) :
root_(0),
next_(0) {
    if (root) addTo(root);
}

template <class R, class N, int n> ListInNode<R, N, n>::ListInNode(R& root) :
root_(0),
next_(0) 
{
    addTo(root);
}

template <class R, class N, int n> ListInNode<R, N, n>::~ListInNode() {
    remove();
}
#endif