tpl_dyn_slist_nc.H

# ifndef TPL_DYN_SLIST_NC_H
# define TPL_DYN_SLIST_NC_H

# include <tpl_snode_nc.H>

namespace Aleph
{
  template <typename T> class Dyn_Slist_Nc : public Snode_Nc <T>
  {
  public:
    typedef Snode_Nc <T> Node;

  private:
    Node * head;
    size_t num_items;

  public:

    void empty()
    {
      while (not this->is_empty())
        delete Node::remove_next();
      this->reset();
      head = this;
      num_items = 0;
    }

    T & insert(const T & data) throw(std::exception, std::bad_alloc)
    {
      Node * p = new Node(data);
      Node::insert(p);

      if (num_items++ == 0)
        head = p;

      return p->get_data();
    }

    T & append(const T & data) throw(std::exception, std::bad_alloc)
    {
      I(head not_eq NULL);
      Node * p = new Node(data);
      head->insert(p);

      head = p;
      ++num_items;
      return p->get_data();
    }

    T & get_first()
    {
      if (this->is_empty())
        throw std::underflow_error("List is empty");

      return this->get_next()->get_data();
    }

    T & get_last()
    {
      if (this->is_empty())
        throw std::underflow_error("List is empty");

      return head->get_data();
    }

    T remove_first()
    {
      if (this->is_empty())
        throw std::underflow_error("List is empty");

      Node * p = Node::remove_next();
      T ret_val = p->get_data();
      delete p;
      if (--num_items == 0)
        head = this;
      return ret_val;
    }

    T & put(const T & item) { return append(item); }

    T get() { return remove_first(); }

    T & rear() { return get_last(); }

    T & front() { return get_first(); }

    T & push(const T & item) { return insert(item); }

    T pop() { return remove_first(); }

    T & top() const { return get_first(); }

    const size_t & size() const { return num_items; }

    class Iterator : public Node::Iterator
    {
    /* TODO: Agregar atributos y métodos que hagan falta
             la implementación de este iterador la hice minimalista
             para pruebas de Dyn_Slist_Nc
    */
    public:
      Iterator(Dyn_Slist_Nc<T> & list) : Node::Iterator(list)
      {
        // empty
      }

      T & get_current()
      {
        return Node::Iterator::get_current()->get_data();
      }

      T & get_curr() { return Dyn_Slist_Nc::Iterator::get_current(); }

    };

    Dyn_Slist_Nc() : Node(), head(this), num_items(0)
    {
      // empty
    }

    Dyn_Slist_Nc(const Dyn_Slist_Nc & l) : Node(l), head(this), num_items(0)
    {
      for (Iterator it(const_cast <Dyn_Slist_Nc &>(l));
           it.has_current(); it.next())
        append(it.get_current());
    } 

    ~Dyn_Slist_Nc()
    {
      empty();
    }

    Dyn_Slist_Nc & operator = (const Dyn_Slist_Nc & list)
    {
      if (this == &list) 
        return *this;
 
      empty();
    
      I(this->is_empty());

      for (Iterator it(const_cast<Dyn_Slist_Nc &>(list)); 
           it.has_current(); it.next())
        append(it.get_current()); 

      return *this;
    }

    T & operator [] (const size_t & n)
    {
      Iterator it(*this);
      for (int i = 0; i < n and it.has_current(); ++i, it.next());

      return it.get_curr();
    }
  };
}

# endif