visptr.h~

ALGAE是一个快速创建算法演示的框架。目前支持的算法实现语言包括java和c

#ifndef VISIBLE_POINTER_H
#define VISIBLE_POINTER_H

#include <algae/config.h>
#include <iostream>
#include <iomanip>
#include <string>

#include <algae/algae.h>
#include <algae/visible.h>


template  <class T, AlgAE::Directions dir>
class VisibleConstPointer: public Visible
{
protected:
  const T* _data;
  AlgAE::Color _color;
public:
  VisibleConstPointer();
  VisibleConstPointer(AlgAE::Color c);
  VisibleConstPointer(const T* p, AlgAE::Color c = AlgAE::Magenta);
  VisibleConstPointer(const T* p, const STD string& name,
		      AlgAE::Color c = AlgAE::Magenta);
  VisibleConstPointer (const VisibleConstPointer<T, dir>& x);
  
  const VisibleConstPointer<T, dir>&
    operator= (const VisibleConstPointer<T, dir>& x);
  const VisibleConstPointer<T, dir>& operator= (const T* x);

  virtual ~VisibleConstPointer();

  const T& operator*() const {return *_data;}
  const T* operator->() const {return _data;}
  
  operator const T*() const  {return _data;}
  
  bool operator< (const VisibleConstPointer<T, dir>& ptr) const
    {
      return _data < ptr._data;
    }
  
  bool operator== (const VisibleConstPointer<T, dir>& ptr) const
    {
      return _data == ptr._data;
    }
  
  bool operator!= (const VisibleConstPointer<T, dir>& ptr) const
    {
      return _data != ptr._data;
    }
  
  bool operator== (const T* ptr) const
    {
      return _data == ptr;
    }
  
  bool operator!= (const T* ptr) const
    {
      return _data != ptr;
    }
  
  // Required for animation
  virtual void touchAllPointers() const;
  virtual void writeText(STD ostream& out) const;
};



template  <class T, AlgAE::Directions dir>
class VisiblePointer: public VisibleConstPointer<T, dir>
{
public:
  VisiblePointer(): VisibleConstPointer<T, dir>(AlgAE::Magenta) {}

  VisiblePointer(AlgAE::Color c): VisibleConstPointer<T, dir>(c) {}

  VisiblePointer(T* p, AlgAE::Color c = AlgAE::Magenta)
    : VisibleConstPointer<T, dir>(p,c) {}
  VisiblePointer(T* p, const STD string& name,
		 AlgAE::Color c = AlgAE::Magenta)
    : VisibleConstPointer<T, dir>(p,name,c) {}

  VisiblePointer (const VisiblePointer<T, dir>& x)
    : VisibleConstPointer<T, dir>(x) {}
  
  const VisiblePointer<T, dir>&
    operator= (const VisibleConstPointer<T, dir>& x);

  const VisiblePointer<T, dir>& operator= (const T* x);

  ~VisiblePointer();
  
  T& operator*() const {return (T&)(*_data);}
  T* operator->() const {return (T*)_data;}
  
  operator T*() const   {return (T*)_data;}
  
  void del ()
    {
      T* d = (T*)(_data);
      delete d;
      _data = 0;
    }
  
};



template  <class T, AlgAE::Directions dir>
VisibleConstPointer<T, dir>::VisibleConstPointer()
  : Visible(AlgAE::Magenta), _color(AlgAE::Magenta), _data(0) {}

template  <class T, AlgAE::Directions dir>
VisibleConstPointer<T, dir>::VisibleConstPointer(AlgAE::Color c)
  : Visible(c), _color(c), _data(0) {}

template  <class T, AlgAE::Directions dir>
VisibleConstPointer<T, dir>::VisibleConstPointer(const T* p, AlgAE::Color c)
  : Visible(c), _color(c), _data(p) {}

template  <class T, AlgAE::Directions dir>
VisibleConstPointer<T, dir>::VisibleConstPointer
 (const T* p, const STD string& name, AlgAE::Color c):
   Visible(c), _color(c), _data(p)
{setName (name);}

template  <class T, AlgAE::Directions dir>
VisibleConstPointer<T, dir>::VisibleConstPointer
 (const VisibleConstPointer& x):
   Visible(x._color), _color(x._color), _data(x._data) {}

template  <class T, AlgAE::Directions dir>
const VisibleConstPointer<T, dir>& VisibleConstPointer<T, dir>::
  operator= (const VisibleConstPointer& x)
{
  _data = x._data;
  return *this;
}

template  <class T, AlgAE::Directions dir>
const VisiblePointer<T, dir>& VisiblePointer<T, dir>::
  operator= (const VisibleConstPointer<T, dir>& x)
{
  VisibleConstPointer<T,dir>::operator= (x);
  return *this;
}

template  <class T, AlgAE::Directions dir>
const VisibleConstPointer<T, dir>& VisibleConstPointer<T, dir>::
  operator= (const T* x)
{
  _data = x;
  return *this;
}

template  <class T, AlgAE::Directions dir>
const VisiblePointer<T, dir>& VisiblePointer<T, dir>::operator= (const T* x)
{
  _data = x;
  return *this;
}

template  <class T, AlgAE::Directions dir>
VisibleConstPointer<T, dir>::~VisibleConstPointer() {}

template  <class T, AlgAE::Directions dir>
VisiblePointer<T, dir>::~VisiblePointer() {}

template  <class T, AlgAE::Directions dir>
void VisibleConstPointer<T, dir>::touchAllPointers() const
{
  touch(_data, dir);
}

template  <class T, AlgAE::Directions dir>
void VisibleConstPointer<T, dir>::writeText(STD ostream& out) const
{
  out << ' ';
}




#endif