tpl_dynSlist.H

/*
  This file is part of Aleph system

  Copyright (c) 2002, 2003, 2004, 2005, 2006
  UNIVERSITY LOS ANDES (ULA) Merida - REPÚBLICA BOLIVARIANA DE VENEZUELA  

  - Center of Studies in Microelectronics & Distributed Systems (CEMISID) 
  - ULA Computer Science Department
  - FUNDACITE Mérida - Ministerio de Ciencia y Tecnología

  PERMISSION TO USE, COPY, MODIFY AND DISTRIBUTE THIS SOFTWARE AND ITS
  DOCUMENTATION IS HEREBY GRANTED, PROVIDED THAT BOTH THE COPYRIGHT
  NOTICE AND THIS PERMISSION NOTICE APPEAR IN ALL COPIES OF THE
  SOFTWARE, DERIVATIVE WORKS OR MODIFIED VERSIONS, AND ANY PORTIONS
  THEREOF, AND THAT BOTH NOTICES APPEAR IN SUPPORTING DOCUMENTATION.

  Aleph is distributed in the hope that it will be useful, but WITHOUT
  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
  or FITNESS FOR A PARTICULAR PURPOSE.

  UNIVERSIDAD DE LOS ANDES requests users of this software to return to 

  Leandro Leon
  CEMISID 
  Ed La Hechicera 
  3er piso, ala sur
  Facultad de Ingenieria 
  Universidad de Los Andes 
  Merida - REPÚBLICA BOLIVARIANA DE VENEZUELA    or

  lrleon@ula.ve

  any improvements or extensions that they make and grant Universidad 
  de Los Andes (ULA) the rights to redistribute these changes. 

  Aleph is (or was) granted by: 
  - Consejo de Desarrollo Cientifico, Humanistico, Tecnico de la ULA 
    (CDCHT)
  - Fundacite Mérida
*/


# 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);

        // obtener nodo predecesor al nuevo elemento
    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 la clase base Slink
  }
  struct Iterator : public Slist<T>::Iterator
  {
    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

---