tpl_slist.H

# ifndef TPL_SLIST_H
# define TPL_SLIST_H

# include <ahDefs.H>
# include <tpl_snode.H>

using namespace Aleph;

namespace Aleph {

template <typename T> class Slist : public Snode<T>
{

public:

  typedef Snode<T> Node;
  Slist() { /* empty */ }
  void insert_first(Node * node)
  {

    I(node not_eq NULL);
    I(node->is_empty());

    this->insert_next(node);
  }
  Node * remove_first() 

    throw(std::exception, std::underflow_error)

  {

    if (this->is_empty())
      throw std::underflow_error ("list is empty");

    return this->remove_next();
  }
  Node * get_first() 

    Exception_Prototypes(std::underflow_error)

  {

    if (this->is_empty())
      throw std::underflow_error ("list is empty");

    return this->get_next(); 
  }
  class Iterator
  {

  private:

    Slist * list;
    Node  * current;

  public:
    typedef Snode<T> Set_Type;
    typedef Snode<T> * Item_Type;

    Iterator(Slist & _list) : list(&_list), current(list->get_first()) {}

    bool has_current() const { return current != list; }

    Node * get_current() 

      throw(std::exception, std::overflow_error)

    {

      if (not this->has_current())
        throw std::overflow_error ("");

      return current;
    }
    void next()

      throw(std::exception, std::overflow_error)

    {

      if (not this->has_current())
        throw std::overflow_error ("");

      current = current->get_next();
    }
    void reset_first() { current = list->get_next(); }
    Iterator & operator = (Node * node)
    {
      if (this == node) 
        return *this;

      current = node;
      return *this;
    }
  };
};

} // end namespace Aleph

# endif /* TPL_SLIST_H */