// List.h
//
// A class List similar to the STL container list.
// Version 1.0
//
// Included in this version:
//   List(), back(), push_back(e), pop_back()

#ifndef _List_h_
#define _List_h_

template <class T>
class List;

template <class T>
class ListNode
// T is the type of element stored in the list.
{
    friend class List<T>;

private:
    ListNode() : element(), next(nullptr), previous(nullptr) {}
    ListNode(const T & e, ListNode * next0, ListNode * previous0);

    T element;
    ListNode<T> * next;
    ListNode<T> * previous;
};

template <class T>
ListNode<T>::ListNode(const T & e, ListNode * next0,
                      ListNode * previous0) :
        element(e), next(next0), previous(previous0) {}

template <class T>
class List
// T is the type of element stored in the list.
{
public:
    List();

    T & back() { return p_head_node->previous->element; }
    const T & back() const
    {
        return p_head_node->previous->element;
    }

    void push_back(const T & new_element);
    void pop_back();

    void test_print() const;  // for testing only

private:
    ListNode<T> * p_head_node;
};

template <class T>
inline List<T>::List()
{
    p_head_node = new ListNode<T>;
    p_head_node->next = p_head_node->previous = p_head_node;
}

template <class T>
inline void List<T>::push_back(const T & new_element)
{
    // set a pointer to the last node
    ListNode<T> * p_last_node = p_head_node->previous;

    // create new node and set its contents
    ListNode<T> * p_new_node =
        new ListNode<T>(new_element, p_head_node, p_last_node);

    // finish linking new node to list
    p_last_node->next = p_new_node;
    p_head_node->previous = p_new_node;
}

template <class T>
inline void List<T>::pop_back()
{
    // set pointers to last node and node that will become last
    ListNode<T> * p_last_node = p_head_node->previous;
    ListNode<T> * p_new_last_node = p_last_node->previous;

    // modify the list to skip the last node
    p_new_last_node->next = p_head_node;
    p_head_node->previous = p_new_last_node;

    // deallocate the last node
    p_last_node->next = p_last_node->previous = nullptr;
    delete p_last_node;
}

template <class T>
void List<T>::test_print() const
{
    for (ListNode<T> * p_node = p_head_node->next;
            p_node != p_head_node;
            p_node = p_node->next) {
        cout << p_node->element << ' ';
    }
    cout << endl;
}

#endif