tpl_dynSlist.H

# ifndef TPL_DYNSLIST_H
# define TPL_DYNSLIST_H

# include <tpl_slist.H>

using namespace Aleph;

namespace Aleph {

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

private:

  size_t num_items;
  int        current_pos;
  Snode<T> * current_node;
  typename Slist<T>::Node * get_previous_to_pos(const int & pos)
  {

    if (pos > num_items)
      throw std::out_of_range ("position out of range");

    if (pos < current_pos) // hay que retroceder?
      { // Si, reinicie posición actual
        current_pos  = 0;
        current_node = this;
      }
    while (current_pos < pos)  // avanzar hasta nodo predecesor a pos
      {
        current_node = current_node->get_next();
        ++current_pos;
      }
    return current_node;
  }

public:

  DynSlist() : num_items(0), current_pos(0), current_node(this)
  { 
    // Empty 
  } 
  T & operator [] (const size_t & i) 

    throw(std::exception, std::out_of_range)

  {
    return get_previous_to_pos(i)->get_next()->get_data();
  }    

  size_t size() const { return num_items; }

  void insert(const int & pos, const T & data) 

    throw(std::exception, std::bad_alloc, std::out_of_range)

  {      // apartar nodo para nuevo elemento
    typename Slist<T>::Node * node = new typename Slist<T>::Node (data);
    typename Slist<T>::Node * prev = get_previous_to_pos(pos); 
    prev->insert_next(node);
    ++num_items;
  }
  void remove(const int & pos) 

    throw(std::exception, std::range_error)

  {      // obtener nodo predecesor al nuevo elemento
    typename Slist<T>::Node * prev = get_previous_to_pos(pos);
    typename Slist<T>::Node * node_to_delete = prev->remove_next();
    delete node_to_delete;
    --num_items;
  }
  ~DynSlist() 
  {      // eliminar nodo por nodo hasta que la lista devenga vacía
    while (not this->is_empty())
      delete this->remove_first(); // remove_first de clase Slink
  }
  class Iterator : public Slist<T>::Iterator
  {
  public:
    typedef Slist<T> Set_Type;
    typedef T Item_Type;

    Iterator(DynSlist & list) : Slist<T>::Iterator(list) { /* Empty */ } 

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

};

} // end namespace Aleph

# endif // TPL_DYNSLIST_H