INF205/lab_3/sequences-int/doubly-linked-list.h

#ifndef DOUBLY_LINKED_LIST_H
#define DOUBLY_LINKED_LIST_H

#include <cassert>
#include "sequence.h"

namespace seq
{
   class DoublyLinkedListNode
   {
   public:
      // return a reference to the stored item
      int& get_item() { return this->item; }

      // return pointer to next node, or nullptr if this is the final node
      DoublyLinkedListNode* get_next() const { return this->next; }

      // return pointer to previous node, or nullptr if this is the initial node
      DoublyLinkedListNode* get_prev() const { return this->prev; }

      // overwrite the item stored in this node
      void set_item(int in_item) { this->item = in_item; }

   private:
      int item = 0;
      DoublyLinkedListNode* next = nullptr;
      DoublyLinkedListNode* prev = nullptr;

      // attach a node behind this node
      // if there was a node attached to this previously, it is NOT deleted!
      void set_next(DoublyLinkedListNode* in_next) { this->next = in_next; }

      // attach a node before this node
      // if there was a node attached to this previously, it is NOT deleted!
      void set_prev(DoublyLinkedListNode* in_prev) { this->prev = in_prev; }
      
      friend class DoublyLinkedList;  // allow DoublyLinkedList to access private members
   };
   
   class DoublyLinkedList: public Sequence
   {
   public:
      bool empty() const { return (this->head == nullptr); }  // test whether the doubly linked list is empty
      size_t size() const;  // return the size (number of items in the doubly linked list)

      // it is the caller's responsibility to ensure that the list is not empty when calling front() or back()!
      int& front() { assert(this->head); return this->head->get_item(); }  // return a reference to the first item
      int& back()  { assert(this->tail); return this->tail->get_item(); }  // return a reference to the final item

      // return a reference to the item at position i of the list, counting from 0
      // for negative numbers, count from the tail (-1) backward (-2, -3, ...)
      // it is the caller's responsibility that the index is within range
      int& at(int i) { return this->index(i)->get_item(); }
      
      // return pointer to the head/tail node
      DoublyLinkedListNode* begin() const { return this->head; }
      DoublyLinkedListNode* end() const { return this->tail; }
      
      // return pointer to the node at position i, counting from 0
      // for negative numbers, count from the tail (-1) backward (-2, -3, ...)
      DoublyLinkedListNode* index(int i) const;

      /*
       * accepts an additional item into the doubly linked list;
       * by default, this is done at the back end of the list
       * call push_front(...) to push an element at the front
       * 
       * the list takes ownership of the copy (but not of the original!)
       */
      void push(const int& pushed_item) { this->push_back(pushed_item); }
      void push_back(const int& pushed_item);
      void push_front(const int& pushed_item);

      /*
       * removes an item from the list (front end by default)
       * to do the same at the back, call pop_back()
       */
      void pop() { this->pop_front(); }
      void pop_front();
      void pop_back();
      void clear() { while(!this->empty()) this->pop(); }  // remove all the items from the list

      // it is the caller's responsibility that the index is within range
      // for negative numbers, count from the tail (-1) backward (-2, -3, ...)
      void insert_at(int i, const int& inserted_item);  // insert an item at index i
      void erase_at(int i);  // remove the item at index i

      // it is the caller's responsibility that the node is actually part of the list
      void insert_successor_to(DoublyLinkedListNode* predecessor, const int& inserted_item);  // insert an item after given node
      void erase_successor_to(DoublyLinkedListNode* predecessor)  // remove the item after given node
      {
         this->erase_node(predecessor->get_next());
      }
      void erase_node(DoublyLinkedListNode* erased_node);
      
      ~DoublyLinkedList() { this->clear(); }

   private:
      DoublyLinkedListNode* head = nullptr;
      DoublyLinkedListNode* tail = nullptr;
   };
}

#endif