tpl_dynDlist.H

# ifndef TPL_DYNDLIST_H
# define TPL_DYNDLIST_H

# include <ahFunctional.H>
# include <ahDry.H>
# include <tpl_dnode.H>

using namespace Aleph;

namespace Aleph {

    template <typename T = int> 
class DynDlist : public Dnode<T>
{
  size_t num_elem;

public:

  typedef DynDlist Set_Type;

  typedef T Item_Type;

  typedef T Key_Type;

  const size_t & size() const { return num_elem; }

  DynDlist() : num_elem(0) { /* Empty */ }

  void empty() 
  {
    while (not this->is_empty())
      delete this->remove_next();

    num_elem = 0;
  }

  ~DynDlist() 
  { 
    empty();
  }

private:
  
  T & __insert(Dnode<T> * p)
  {
    Dnode<T>::insert(p);
    ++num_elem;
    return p->get_data();
  }

  T & __append(Dnode<T> * p)
  {
    Dnode<T>::append(p);
    ++num_elem;
    return p->get_data();
  }

public:

  T & insert(const T & item) throw(std::exception, std::bad_alloc)
  {
    return __insert(new Dnode<T> (item));
  }

  T & insert(T && item) 
  {
    return __insert(new Dnode<T> (std::move(item)));
  }

  T & append(const T & item) throw(std::exception, std::bad_alloc)
  {
    return __append(new Dnode<T> (item));
  }

  T & append(T && item) throw(std::exception, std::bad_alloc)
  {
    return __append(new Dnode<T> (std::move(item)));
  }

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

    I(list.is_empty());

    return 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;
  }

  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 this->get_next()->get_data();
  }

  const T & get_first() const throw(std::exception, std::underflow_error)
  {
    return const_cast<DynDlist&>(*this).get_next()->get_data();
  }

  T & get_last() throw(std::exception, std::underflow_error)
  {
    return this->get_prev()->get_data();
  }

  const T & get_last() const throw(std::exception, std::underflow_error)
  {
    return const_cast<DynDlist&>(*this).get_prev()->get_data();
  }

  T remove_first() throw(std::exception, std::underflow_error)
  {
    Dnode<T> * ptr = this->remove_next();
    T retVal = ptr->get_data();
    delete ptr;
    --num_elem;

    return retVal;
  }

  T remove_last() throw(std::exception, std::underflow_error)
  {
    Dnode<T> * ptr = this->remove_prev();
    T retVal = ptr->get_data();
    delete ptr;
    --num_elem;

    return retVal;
  }

  T & put(const T & item) { return append(item); }

  T & put(T && item) { return append(std::move(item)); }

  T get() { return remove_first(); }

  T & rear() { return get_last(); }

  T & front() { return get_first(); }

  T & push(const T & item) { return insert(item); }

  T & push(T && item) { return insert(std::move(item)); }

  T pop() { return remove_first(); }

  T & top() const { return get_first(); }
  
  void remove(T & data)
  {
    Dnode<T> * p = Dnode<T>::data_to_node(data);
    p->del();
    delete p;
    --num_elem;
  }

  void erase(T & data)
  {
    remove(data);
  }

  void swap(DynDlist & l)
  {
    std::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 Dnode<T>::Iterator
  {
    DynDlist * list_ptr; // puntero a la lista
    int        pos;      // posición del elemento actual en la secuencia

  public:
    typedef DynDlist Set_Type;

    typedef T Item_Type;

    const int & get_pos() const { return pos; }

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

    const int & prev()
    {
      Dnode<T>::Iterator::prev();
      pos--;
      return pos;
    }

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

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

    Iterator(DynDlist<T> & _list) 
      : Dnode<T>::Iterator(_list), list_ptr(&_list), pos(0) 
    {
      // empty
    }

    Iterator(const DynDlist<T> & _list) 
      : Dnode<T>::Iterator(const_cast<DynDlist<T>&>(_list)), 
        list_ptr(&const_cast<DynDlist<T>&>(_list)), pos(0) 
    {
      // empty
    }

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

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

      return *this;
    }

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

    T & get_curr() const
    {
      return get_current(); 
    }

    void insert(const T & item) 
      throw(std::exception, std::overflow_error, std::bad_alloc)
    {
      if (not this->has_current())
        throw std::overflow_error ("DynDlist Iterator has not current");

      Dnode<T>::Iterator::get_current()->insert(new Dnode<T>(item));
      ++list_ptr->num_elem;
    }

    void insert(T && item) 
      throw(std::exception, std::overflow_error, std::bad_alloc)
    {
      if (not this->has_current())
        throw std::overflow_error ("DynDlist Iterator has not current");

      Dnode<T>::Iterator::get_current()->
        insert(new Dnode<T>(std::move(item)));
      ++list_ptr->num_elem;
    }

    void append(const T & item) 
      throw(std::exception, std::overflow_error, std::bad_alloc)
    {
      if (not this->has_current())
        throw std::overflow_error ("DynDlist Iterator has not current");

      Dnode<T>::Iterator::get_current()->append(new Dnode<T>(item));
      ++list_ptr->num_elem;
    }

    void append(T && item) 
      throw(std::exception, std::overflow_error, std::bad_alloc)
    {
      if (not this->has_current())
        throw std::overflow_error ("DynDlist Iterator has not current");

      Dnode<T>::Iterator::get_current()->
        append(new Dnode<T>(std::move(item)));
      ++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");

      Dnode<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");

      Dnode<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");

      Dnode<T> * ptr = Dnode<T>::Iterator::get_current(); 
      T ret_val      = ptr->get_data(); 
      Dnode<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 = Dnode<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 = Dnode<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->Dnode<T>::cut_list(Dnode<T>::Iterator::get_current(), &list);
      list.num_elem = list_ptr->num_elem - pos; 
      list_ptr->num_elem -= pos;

      return list.num_elem;
    }
  };

  DynDlist<T> & operator = (const DynDlist & list)
  {
    if (this == &list) 
      return *this;

    empty();

    I(this->is_empty());

    for (typename DynDlist<T>::Iterator itor(const_cast<DynDlist&>(list)); 
         itor.has_current();itor.next())
      this->append(itor.get_current()); 

    return *this;
  }

  DynDlist(const DynDlist & list) : Dnode<T>(list)
  {
    this->reset();
    num_elem = 0;
    
    I(this->is_empty());

    for (typename DynDlist<T>::Iterator itor(const_cast<DynDlist&>(list)); 
         itor.has_current();itor.next())
      this->append(itor.get_current()); 
  }

  DynDlist(DynDlist<T> && list) : Dnode<T>(std::move(list)), num_elem(0)
  {
    swap(list);
  }

  DynDlist(std::initializer_list<T> l)
  {
    std::for_each(l.begin(), l.end(), /* Lambda */ [this] (const T & item)
                  {
                    append(item);
                  }
                  );
  }

  DynDlist<T> & operator = (DynDlist && list)
  {
    swap(list);
    return *this;
  }
 
  T & operator [] (const size_t & n)
  {
    typename DynDlist<T>::Iterator it(*this);

    for (int i = 0; i < n and it.has_current(); i++, it.next()) ;

    return it.get_current();
  }

  Generic_Traverse(T);

  Functional_Methods(T);
};

} // end namespace Aleph

# endif /* TPL_DYNDLIST_H */