tpl_dnode.H

# ifndef TPL_DNODE_H
# define TPL_DNODE_H

# include <ahFunction.H>
# include <dlink.H>

using namespace Aleph;

namespace Aleph {

template <typename T> class Dnode : public Dlink 
{
private:

  mutable T data;

public:

  Dnode<T> *& get_next() { return (Dnode<T>*&) next; }

  Dnode<T> *& get_prev() { return (Dnode<T>*&) prev; }

  Dnode<T>* remove_prev() { return (Dnode<T>*) Dlink::remove_prev(); }

  Dnode<T>* remove_next() { return (Dnode<T>*) Dlink::remove_next(); }

  Dnode<T> *& get_first() { return reinterpret_cast<Dnode<T>*&>(next); } 

  Dnode<T> *& get_last() { return reinterpret_cast<Dnode<T>*&> (prev); }

  Dnode<T>* remove_last() 
  {
    return static_cast<Dnode<T>*>(Dlink::remove_prev()); 
  }

  Dnode<T>* remove_first() 
  {
    return static_cast<Dnode<T>*>(Dlink::remove_next()); 
  }
  
  Dnode() { /* nothing */ }

  Dnode(const T & item) : data(item) 
  {
    // empty
  }

  Dnode(T && item)
  {
    std::swap(data, item);
  }

  Dnode & swap(Dnode & p)
  {
    Dlink::swap(p);
    std::swap(data, p.data);
    return *this;
  }

  Dnode & swap(Dnode * p)
  {
    return swap(*p);
  }

  Dnode(const Dnode & node) : Dlink(), data(node.data) 
  {
    /* empty */ 
  }

  Dnode(Dnode && node) : data(std::move(node).data) 
  {
    /* empty */ 
  }

  Dnode & operator = (const Dnode & p)
  {
    if (&p == this)
      return *this;
  
    data = p.data;

    return *this;
  }

  Dnode & operator = (Dnode && p)
  {
    std::swap(data, p.data);
    return *this;
  }

  Dnode & operator = (const T & _data)
  {
    data = _data;
    return *this;
  } 

  Dnode & operator = (T && _data)
  {
    data = std::move(_data);
    return *this;
  } 
  T & get_data() { return data; }

  typedef T key_type;

  T & get_key() { return data; }

  typedef T dnode_type;

  static Dnode * data_to_node(T & data)
  {
    Dnode * zero = 0;
    long offset = (long) &(zero->data);
    unsigned long  addr = (unsigned long) (&data);
    return (Dnode*) (addr - offset);
  }

  class Iterator : public Dlink::Iterator
  {
  public:
    
    typedef Dnode<T> Set_Type;
    
    typedef Dnode<T>* Item_Type;

    Iterator() { /* empty */ }

    Iterator(Dlink * head_ptr) : Dlink::Iterator(head_ptr) { /* empty */ }

    Iterator(Dlink & head) : Dlink::Iterator(&head) { /* empty */ }

        // Instancia iterador en lista cuyo nodo cabecera es head_ptr y
        // coloca el elemento actual en el apuntado por curr_ptr 
    Iterator(Dlink * head_ptr, Dnode * curr_ptr) 
      : Dlink::Iterator(head_ptr, curr_ptr)
    {
      // Empty
    }

    Iterator & operator = (Dnode * head)
    {
      Dlink::Iterator::operator = (head);
      return *this;
    }

    Dnode<T> * get_current() const 
    {
      return static_cast<Dnode<T>*>(this->Dlink::Iterator::get_current()); 
    }

    Dnode<T> * get_curr() const 
    {
      return Dnode<T>::Iterator::get_current(); 
    }

    Dnode * del() { return static_cast<Dnode*>(Dlink::Iterator::del()); }
  };
};

}

# endif /* TPL_DNODE_H */