slink_nc.H

# ifndef SLINK_NC_H
# define SLINK_NC_H

# include <aleph.H>

namespace Aleph
{
  class Slink_Nc
  {
  protected:
    Slink_Nc * next;
  
  public:
    Slink_Nc() : next(NULL) { /* empty */ }

    Slink_Nc(const Slink_Nc &) : next(NULL) { /* empty */ }

    ~Slink_Nc() { /* empty */ }

    Slink_Nc & operator = (const Slink_Nc & link)
    {
      if (&link == this)
        return *this;

      if (not is_empty())
        throw std::invalid_argument("link is not empty");

      next = NULL; 
    }

    void reset()
    {
      I(this not_eq NULL);
      next = NULL;
    }

    bool is_empty() const
    {
      I(this not_eq NULL);
      return next == NULL;
    }

    Slink_Nc *& get_next()
    {
      I(this not_eq NULL);
      return next;
    }

    void insert(Slink_Nc * p)
    {
      I(this not_eq NULL);
      I(p not_eq NULL);
      I(p->is_empty());
      p->next = next;
      next = p;
    }

    Slink_Nc * remove_next()
    {
      I(this not_eq NULL);
      Slink_Nc * ret_val = next;
      next = ret_val->next;
      ret_val->reset();
      return ret_val;
    }

    class Iterator
    {
      Slink_Nc * head;
      Slink_Nc * curr;
    
    public:
      Iterator() : head(NULL), curr(NULL) { /* Empty */ }

      Iterator(Slink_Nc * head_ptr) : head(head_ptr), curr(head->get_next())
      { 
        // empty
      }

      Iterator(Slink_Nc & _head) : head(&_head), curr(head->get_next())
      { 
        // empty
      }

      Iterator(Slink_Nc * head_ptr, Slink_Nc * curr_ptr)
        : head(head_ptr), curr(curr_ptr)
      {
        // empty
      }

      void reset_first() 
      {
        I(curr != NULL and head != NULL);
        curr = head->get_next();
      }

      void set(Slink_Nc * new_curr) 
      {
        I(curr != NULL and head != NULL);
        curr = new_curr;
      }

      void reset(Slink_Nc * new_head)
      {
        head = new_head;
        curr = head->get_next();;
      }

      bool has_current() const 
      {
        I(head != NULL);
        return curr != NULL;
      }

      // sinónimo de has_current()
      bool has_curr() const { return has_current(); }

      Slink_Nc * get_current()  
      {
        I(curr != NULL and head != NULL);

        if (not has_current())
          throw std::overflow_error("Not element in list");

        return curr;
      }

      // sinónimo de get_current()
      Slink_Nc * get_curr() { return get_current(); }

      bool is_in_first() const { return curr == head->next; }

      void next() throw(std::exception, std::overflow_error)
      {
        if (not has_current())
          throw std::overflow_error("Not next element in list");

        curr = curr->get_next();
      }

      bool operator == (const Iterator & it) const { return curr == it.curr; }

      bool operator != (const Iterator & it) const { return curr != it.curr; }
    
      bool verify(Slink_Nc * l) const { return head == l; }

      bool verify(const Iterator & it) const { return head == it.head; }
    };
    
  };
}

# endif