tpl_dynDlist.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_DYNDLIST_H
# define TPL_DYNDLIST_H

# include <tpl_dlist.H>

using namespace Aleph;

namespace Aleph {

    template <typename T>
class DynDlist : public Dlist<T>
{

  size_t num_elem;
public:

  const size_t & size() const { return num_elem; }
  DynDlist() : num_elem(0) { /* Empty */ }
  void insert(const T & _data) 

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

  {
    typename Dlist<T>::Node* ptr = new typename Dlist<T>::Node (_data);
    Dlist<T>::insert(ptr);
    ++num_elem;
  }

  void append(const T & _data) 

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

  {
    typename Dlist<T>::Node* ptr = new typename Dlist<T>::Node (_data);
    Dlist<T>::append(ptr);
    ++num_elem;
  }
  size_t insert_list(DynDlist & list)
  {
    Dlink::insert_list(&list);
    num_elem += list.num_elem;
    list.num_elem = 0;


    I(list.is_empty());

    return num_elem;
  }

  size_t append_list(DynDlist & list)
  {
    Dlink::append_list(&list);
    num_elem += list.num_elem;
    list.num_elem = 0;


    I(list.is_empty());

    return num_elem;
  }
  T & get_first() 

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

  {
    return Dlist<T>::get_first()->get_data();
  }

  T & get_last() 

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

  {
    return Dlist<T>::get_last()->get_data();
  }
  T remove_first() 

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

  {
    typename Dlist<T>::Node* ptr = Dlist<T>::remove_first();
    T retVal = ptr->get_data();
    delete ptr;

    --num_elem;

    return retVal;
  }

  T remove_last() 

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

  {
    typename Dlist<T>::Node* ptr = Dlist<T>::remove_last();
    T retVal = ptr->get_data();
    delete ptr;

    --num_elem;

    return retVal;
  }
  void empty() 
  {
    while (not this->is_empty())
      {
        typename Dlist<T>::Node* ptr = Dlist<T>::remove_first();

        delete ptr;
      }
    
    num_elem = 0;
  }
  ~DynDlist() 
  { 
    empty();
  }
  void swap(DynDlist & l)
  {
    Aleph::swap(num_elem, l.num_elem);
    this->Dlink::swap(&l);
  }
  void split_list(DynDlist & l, DynDlist & r) 

    throw(std::exception, std::domain_error)

  {

    if ((not l.is_empty()) or (not r.is_empty()))
      throw std::domain_error("lists are not empty");

    Dlink::split_list(l, r);

    l.num_elem = r.num_elem = num_elem/2;

    if (num_elem % 2 == 1) // ¿es num_elem impar?
      l.num_elem++;

    num_elem = 0;
  }
  class Iterator : public Dlist<T>::Iterator
  {
    DynDlist * list_ptr;
    int pos;

  public:


    const int & get_pos() const { return pos; }
    const int & next()
    {
      Dlist<T>::Iterator::next();
      pos++;

      return pos;
    }

    const int & prev()
    {
      Dlist<T>::Iterator::prev();
      pos--;

      return pos;
    }

    const int & reset_first()
    {
      Dlist<T>::Iterator::reset_first();
      pos = 0;

      return pos;
    }

    const int & reset_last()
    {
      Dlist<T>::Iterator::reset_last();
      pos = list_ptr->num_elem - 1;

      return pos;
    }
    Iterator(DynDlist<T> & _list) 
      : Dlist<T>::Iterator(_list), list_ptr(&_list), pos(0)
    { /* Empty */ }

    Iterator(const DynDlist<T> & _list) 
      : Dlist<T>::Iterator(const_cast<DynDlist<T>&>(_list)), 
        list_ptr(&const_cast<DynDlist<T>&>(_list)), pos(0)
    { /* Empty */ }


    Iterator(const Iterator & it) 
      : Dlist<T>::Iterator(it), list_ptr(it.list_ptr), pos(it.pos)
    { /* Empty */ }

    Iterator() : list_ptr(NULL){ /* empty */ }

    Iterator & operator = (const Iterator & it) 
    { 
      Dlist<T>::Iterator::operator = (it);
      list_ptr = it.list_ptr;
      pos      = it.pos;

      return *this;
    }
    T & get_current() { return Dlist<T>::Iterator::get_current()->get_data(); }
    void insert(const T & _data) 

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

    {

      if (not this->has_current())
        throw std::overflow_error ("DynDlist Iterator has not current");

      typename Dlist<T>::Node* node = new typename Dlist<T>::Node (_data);
      Dlist<T>::Iterator::get_current()->insert(node);
      ++list_ptr->num_elem;
    }

    void append(const T & _data) 

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

    {

      if (not this->has_current())
        throw std::overflow_error ("DynDlist Iterator has not current");

      typename Dlist<T>::Node* node = new typename Dlist<T>::Node (_data);
      Dlist<T>::Iterator::get_current()->append(node);
      ++list_ptr->num_elem;
    }
    void insert_list(const DynDlist & list) 

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

    {

      if (not this->has_current())
        throw std::overflow_error ("DynDlist Iterator has not current");

      Dlist<T>::Iterator::get_current()->insert_list(&list);
      list_ptr->num_elem += list.num_elem;
      list.num_elem = 0;

      I(list.is_empty());

    }

    void append_list(const DynDlist & list) 

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

    {

      if (not this->has_current())
        throw std::overflow_error ("DynDlist Iterator has not current");

      Dlist<T>::Iterator::get_current()->append_list(&list);
      list_ptr->num_elem += list.num_elem;
      list.num_elem = 0;

      I(list.is_empty());

    }
    T del() 

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

    {

      if (not this->has_current())
        throw std::overflow_error ("DynDlist Iterator has not current");

      typename Dlist<T>::Node* ptr = Dlist<T>::Iterator::get_current(); 

      T ret_val = ptr->get_data(); 

      Dlist<T>::Iterator::next();

      ptr->del();
      delete ptr;

      --list_ptr->num_elem;

      return ret_val;
    }
    T remove_prev()

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

    {

      if (not this->has_current())
        throw std::overflow_error ("DynDlist Iterator has not current");

      Dnode<T> * curr_ptr = Dlist<T>::Iterator::get_current(); 

      Dnode<T> * ptr = curr_ptr->remove_prev();

      T ret_val = ptr->get_data(); 

      delete ptr;

      --list_ptr->num_elem;

      return ret_val;
    }

    T remove_next() 

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

    {

      if (not this->has_current())
        throw std::overflow_error ("DynDlist Iterator has not current");

      Dnode<T> * curr_ptr = Dlist<T>::Iterator::get_current(); 

      Dnode<T> * ptr = curr_ptr->remove_next();

      T ret_val = ptr->get_data(); 

      delete ptr;

      --list_ptr->num_elem;

      return ret_val;
    }
    size_t cut_list(DynDlist & list)
    {

      if (not this->has_current())
        throw std::overflow_error ("DynDlist Iterator has not current");

      list_ptr->Dlist<T>::cut_list(Dlist<T>::Iterator::get_current(), 
                                   &list); // cortar lista

      list.num_elem = list_ptr->num_elem - pos; // actualizar cardinalidad de list
      list_ptr->num_elem -= pos; // actualizar cardinalidad de ptr_list.

      return list.num_elem;
    }
  };
  DynDlist<T> & operator = (const DynDlist & list)
  {

    if (this == &list)
      return *this;

    while (not this->is_empty()) // vaciar this
      this->remove_first();

    
    I(this->is_empty());

    typename DynDlist<T>::Iterator itor(const_cast<DynDlist&>(list)); 

    while (itor.has_current())
    {
      this->append(itor.get_current()); 

      itor.next();
    }

    return *this;
  }
  DynDlist(const DynDlist & list) : Dlist<T>(list)
  {
    this->reset();
    
    I(this->is_empty());

    typename DynDlist<T>::Iterator itor(const_cast<DynDlist&>(list)); 

    while (itor.has_current())
    {
      this->append(itor.get_current()); 

      itor.next();
    }
  }
};

} // end namespace Aleph

# endif /* TPL_DYNDLIST_H */

---