node.hpp

Go to the documentation of this file.

#ifndef _CSDBG_NODE
#define _CSDBG_NODE 1

#include "./object.hpp"

namespace csdbg {

template <class T>
class node: virtual public object
{
protected:

  /* Protected variables */

  node *m_link;         
  T *m_data;            
  /* Protected constructors, copy constructors and destructor */

  explicit node(T*);

  node(const node&);

  virtual ~node();

  virtual node* clone() const;


  /* Protected accessor methods */

  virtual node* link(const node* = NULL) const;

  virtual node& link_to(const node*);

  virtual node& unlink_from(const node*);

  virtual T* detach();


  /* Protected operator overloading methods */

  virtual node& operator=(const node&);

  virtual node* operator^(const node&) const;


  /* Friend classes and functions */

  template <class F> friend class chain;

  template <class F> friend class stack;
};


template <class T>
inline node<T>::node(T *d):
m_link(NULL),
m_data(d)
{
}


template <class T>
inline node<T>::node(const node &src):
m_link(NULL),
m_data(NULL)
{
  if ( likely(src.m_data != NULL) )
    m_data = new T(*src.m_data);
}


template <class T>
inline node<T>::~node()
{
  delete m_data;
  m_data = NULL;
  m_link = NULL;
}


template <class T>
inline node<T>* node<T>::clone() const
{
  return new node(*this);
}


template <class T>
inline node<T>* node<T>::link(const node<T> *prev) const
{
  mem_addr_t addr = reinterpret_cast<mem_addr_t> (m_link);
  mem_addr_t mask = reinterpret_cast<mem_addr_t> (prev);
  return reinterpret_cast<node<T>*> (addr ^ mask);
}


template <class T>
inline node<T>& node<T>::link_to(const node<T> *n)
{
  m_link = link(n);
  return *this;
}


template <class T>
inline node<T>& node<T>::unlink_from(const node<T> *n)
{
  m_link = link(n);
  return *this;
}


template <class T>
inline T* node<T>::detach()
{
  T *retval = m_data;
  m_data = NULL;
  return retval;
}


template <class T>
node<T>& node<T>::operator=(const node &rval)
{
  if ( unlikely(this == &rval) )
    return *this;

  T *data = rval.m_data;
  if ( unlikely(data == NULL) ) {
    delete m_data;
    m_data = NULL;
  }

  else if ( unlikely(m_data == NULL) )
    m_data = new T(*data);

  else
    *m_data = *data;

  return *this;
}


template <class T>
inline node<T>* node<T>::operator^(const node<T> &prev) const
{
  return link(&prev);
}

}

#endif