DListIn.hpp

Go to the documentation of this file.

#ifndef DListIn_HPP
#define DListIn_HPP

#include "DListIn.h"

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

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

template <class R, class N, int n> inline void DListInNode<R, N, n>::remove() {
    if (root_) {
        if (next_) { // if someone after us, update their back pointer
            static_cast<Node*>(next_)->prev_ = prev_;
        } else {
            // Else update end of list pointer
            static_cast<Root*>(root_)->last_ = prev_;
        }
        if (prev_) { // if someone before us, update their next pointer
            static_cast<Node*>(prev_)->next_ = next_;
        } else { // if no one before us update list head
            static_cast<Root*>(root_)->first_ = next_;
        }
        next_ = 0;
        prev_ = 0;
        root_ = 0;
    }
}

template <class R, class N, int n_> inline void DListInRoot<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 DListInRoot<R, N, n_>::remove(N* node) {
    if (node != 0) remove(*node);
}

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

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

    mynode.root_ = static_cast<R*>(this);
    if (first_ == 0) {
        // Empty list, point tail pointer too.
        last_ = &node;
    }
    mynode.next_ = first_;
    mynode.prev_ = 0;
    first_ = &node;
}

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

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

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

    if (last_ == 0) {
        // Empty List
        first_ = &node;
        mynode.prev_ = 0;
    } else {
        mynode.prev_ = last_;
        static_cast<Node*>(last_)->next_ = &node;
    }
    last_ = &node;
    mynode.next_ = 0;
    mynode.root_ = static_cast<R*>(this);
}

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



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


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

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

template<class R, class N, int n> inline void DListInNode<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 DListInNode<R, N, n>::addToEnd(R& root) {
    static_cast<Root&>(root).addLast(*static_cast<N*>(this));
}


template<class R, class N, int n> inline void DListInNode<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 DListInNode<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_;
        prev_ = &node;
        mynode.next_ = me;
        if (next_) {
            static_cast<Node*>(next_)->prev_ = me;
        } else {
            static_cast<Root*>(root_)->last_ = me;
        }
    }
}

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

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

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


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

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

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

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

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