/*
 * Ordered_List.h    TDDD38, Exercise on list iterators.
 */
#ifndef ORDEREDLIST_H
#define ORDEREDLIST_H
#include <initializer_list>
#include <iterator>
// TO BE REMOVED WHEN ITERATORS ADDED:
#include <iostream>

/*
 * List_Node
 */
template<typename T>
struct List_Node
{
   explicit List_Node(const T& value, List_Node* next = nullptr)
      : data_{ value }, next_{ next } 
   {}
	 
   ~List_Node() { delete next_; }

   List_Node(const List_Node&) = delete;
   List_Node& operator=(const List_Node&) = delete;
	 
   T          data_;
   List_Node* next_;
};

/*
 * List iterators
 */
// TO DO

/*
 * Ordered_List
 */

template<typename T, class Compare = std::less<T> >
class Ordered_List
{
public:
   // types
   using value_type      = T;
   using pointer         = T*;
   using const_pointer   = const T*;
   using reference       = T&;
   using const_reference = const T&;
   
   // construct/copy/destroy
   Ordered_List() : head_{ nullptr }, cmp_{ Compare() } {}
   Ordered_List(const Ordered_List& other) : head_{ copy_(other.head_) }, cmp_{ other.cmp_} {}
   Ordered_List(Ordered_List&& other) noexcept { swap(other); }
   Ordered_List(std::initializer_list<T>);

   ~Ordered_List() { delete head_; };

   Ordered_List& operator=(const Ordered_List&) &;
   Ordered_List& operator=(Ordered_List&&) & noexcept;

   // modifiers
   void insert(const T& value);
   void erase(const T& value);
   void swap(Ordered_List&);

   // capacity
   void clear();
   bool empty() const;

   // TO BE REMOVED WHEN ITERATORS ADDED:
   void print() const
   {
      for (auto p = head_; p != nullptr; p = p->next_)
	 std::cout << p->data_ << ' ';
   }

   // iterators
   // TO DO  
	 
private:
   List_Node<T>* head_{ nullptr };
   Compare       cmp_;
	 
   List_Node<T>* copy_(const List_Node<T>*) const;
   void insert_(List_Node<T>*);
};
   
template<typename T, class Compare>
void swap(Ordered_List<T, Compare>& x, Ordered_List<T, Compare>& y)
{
   x.swap(y);
}

#include "Ordered_List.tcc"

#endif