tpl_dlist.H

# ifndef TPL_DLIST_H
# define TPL_DLIST_H

# include <tpl_dnode.H>

using namespace Aleph;

namespace Aleph {

    template <typename T>
class Dlist_Node : public Dnode<T>
{
public:

  Dlist_Node() : Dnode<T>() { /* Empty */ }

  Dlist_Node(const T & _data) : Dnode<T>(_data) { /* Empty */ }
};
    template <typename T>
class Dlist_Node_Vtl : public Dlist_Node<T>
{
public:

  Dlist_Node_Vtl() : Dlist_Node<T>() { /* Empty */ }

  virtual ~Dlist_Node_Vtl() { /* Empty */ }

  Dlist_Node_Vtl(const T & _data) : Dlist_Node<T>(_data) { /* Empty */ }
};  
    template <template <class> class Node, typename T>
class MetaDlistNode : public Node<T>
{
public:

  MetaDlistNode() { /* Empty */ }

  MetaDlistNode(const T& _data) : Node<T>(_data) { /* Empty */ }

  MetaDlistNode(const MetaDlistNode<Node, T> & node) 
    : Node<T>(node) { /* Empty */ }

  MetaDlistNode<Node, T> *& get_next() 
  {
    return (MetaDlistNode<Node, T> *&) Node<T>::get_next(); 
  }
  MetaDlistNode<Node, T> *& get_prev()  
  {
    return (MetaDlistNode<Node, T> *&) Node<T>::get_prev(); 
  }
};
    template <template <class> class Node_Type, typename T>
class GenDlist : public MetaDlistNode<Node_Type, T>
{
public:

  typedef MetaDlistNode<Node_Type,T> Node;
  Node * get_first() 
    throw(std::exception, std::underflow_error)
  {
    if (this->is_empty())
      throw std::underflow_error ("List is empty");

    return this->get_next();
  }
  Node * get_last() 
    throw(std::exception, std::underflow_error)
  {
    if (this->is_empty())
      throw std::underflow_error ("List is empty");
    return this->get_prev();
  }
  Node * remove_first() 
    throw(std::exception, std::underflow_error)
  {
    if (this->is_empty())
      throw std::underflow_error ("List is empty");

    Node* retValue = this->get_next();
    retValue->del();
    return retValue;
  }
  Node * remove_last() 
    throw(std::exception, std::underflow_error)
  {
    if (this->is_empty())
      throw std::underflow_error ("List is empty");
    Node* retValue = this->get_prev();
    retValue->del();
    return retValue;
  }
  class Iterator : public Node::Iterator
  {
  public:
    typedef GenDlist<Node_Type, T> Set_Type;

    typedef Node * Item_Type;

    Iterator(GenDlist<Node_Type, T> & list) : Node::Iterator(&list) { }

    Iterator(GenDlist<Node_Type, T> & list, GenDlist<Node_Type, T> * curr) 
      : Node::Iterator(&list, curr) 
    {
      // Empty
    }

    Iterator() : Node::Iterator() { /* empty */ }

    Iterator(const Iterator & it) : Node::Iterator(it) { /* Empty */ }

    Iterator & operator = (const Iterator & it) 
    {
      if (this == &it)
        return *this;

      Node::Iterator::operator = (it);
      return *this;
    }
    Node * get_current() { return (Node*) Node::Iterator::get_current(); }

    Node * del() { return (Node*) Node::Iterator::del(); }
  };
};
    template <typename T> 
class Dlist : public GenDlist<Dlist_Node, T> 
{
public:

  typedef typename GenDlist<Dlist_Node, T>::Node Node;

  typedef typename GenDlist<Dlist_Node, T>::Iterator Iterator;
};
    template <typename T> 
class DlistVtl : public GenDlist<Dlist_Node_Vtl, T> 
{
public:

  typedef typename GenDlist<Dlist_Node_Vtl, T>::Node Node;

  typedef typename GenDlist<Dlist_Node_Vtl, T>::Iterator Iterator;
};

} // end namespace Aleph

# endif /* TPL_DLIST_H */