visvectr.h

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

#ifndef VISIBLE_VECTOR_H
#define VISIBLE_VECTOR_H

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

#include <utils/indexable.h>

#include <cstddef>
#include <iterator>
#include <string>

#include <vector>

#define Vector STD vector

template <class T>
class VisibleVector;


template <class T>
class visible_vector_const_iterator
  : public Visible, public random_access_iterator<T, ptrdiff_t>
{
protected:
  friend class VisibleVector<T>;
  
  typedef Vector<T>::const_iterator vIterator;
  
  const Vector<T>* container;
  vIterator position;
  
  visible_vector_const_iterator
    (vIterator p, const Vector<T>* cont, AlgAE::Color color = AlgAE::Cyan)
    : position(p), container(cont), Visible(color) {}

public:
  

  visible_vector_const_iterator(AlgAE::Color color = AlgAE::Yellow)
    : Visible(color), container(0) {}
  visible_vector_const_iterator(const visible_vector_const_iterator& i)
    : Visible(i.color()), position(i.position), container(i.container) {}
  
  const visible_vector_const_iterator& operator=
    (const visible_vector_const_iterator& x)
    {
      position = x.position;
      container = x.container;
      return *this;
    }
  
  
  const T& operator*() const
    {
      return *position;
    }
  
  visible_vector_const_iterator& operator++ () // prefix
    {
      ++position;
      return *this;
    }
  
  visible_vector_const_iterator operator++ (int)  // postfix: int argument is ignored
    {
      visible_vector_const_iterator oldValue = *this;
      ++position;
      return oldValue;
    }

  visible_vector_const_iterator& operator-- () // prefix
    {
      --position;
      return *this;
    }

  visible_vector_const_iterator operator-- (int)  // postfix: int argument is ignored
    {
      visible_vector_const_iterator oldValue = *this;
      --position;
      return oldValue;
    }
  
  visible_vector_const_iterator operator+ (unsigned long n) const
    {
      return visible_vector_const_iterator<T>(position+n, container, color());
    }

  visible_vector_const_iterator operator- (unsigned long n) const
    {
      return visible_vector_const_iterator<T>(position-n, container, color());
    }

  int operator- (visible_vector_const_iterator i) const
    {
      return position - i.position;
    }

  bool operator== (const visible_vector_const_iterator& i) const
    {
      return position == i.position;
    }

  bool operator!= (const visible_vector_const_iterator& i) const
    {
      return position != i.position;
    }
  
  // Required for animation
  virtual void touchAllPointers() const
    {
      if (container != 0)
	{
	  if (position != (container->end()))
	    touch (*position, AlgAE::AnyDir);
	}
    }

  virtual void writeText(ostream& out) const
    {
      out << " ";
    }

};





//////////////////////////////////////////////////////////////


template <class T>
class visible_vector_iterator
  : public Visible, public random_access_iterator<T, ptrdiff_t>
{
protected:
  friend class VisibleVector<T>;
  
  typedef Vector<T>::iterator vIterator;
  
  vIterator position;
  Vector<T>* container;
  
  visible_vector_iterator
  (vIterator p, vector<T>* cont, AlgAE::Color color = AlgAE::Cyan)
    : position(p), container(cont), Visible(color) {}
  
public:
  
  
  visible_vector_iterator(AlgAE::Color color = AlgAE::Yellow)
    : Visible(color), container(0) {}
  visible_vector_iterator(const visible_vector_iterator& i)
    : Visible(i.color()), position(i.position), container(i.container) {}
  
  const visible_vector_iterator& operator=
  (const visible_vector_iterator& x)
    {
      position = x.position;
      container = x.container;
      return *this;
    }
  
  
  T& operator*() const
    {
      return *position;
    }
  
  visible_vector_iterator& operator++ () // prefix
    {++position;
    return *this;}
  
  visible_vector_iterator operator++ (int)  // postfix: int argument is ignored
    {
      visible_vector_iterator oldValue = *this;
      ++position;
      return oldValue;
    }

  visible_vector_iterator& operator-- () // prefix
    {
      --position;
      return *this;
    }
  
  visible_vector_iterator operator-- (int)  // postfix: int argument is ignored
    {
      visible_vector_iterator oldValue = *this;
      --position;
      return oldValue;
    }
  
  visible_vector_iterator operator+ (unsigned long n) const
    {
      return visible_vector_iterator<T>(position+n, container, color());
    }

  visible_vector_iterator operator- (unsigned long n) const
    {
      return visible_vector_iterator<T>(position-n, container, color());
    }

  int operator- (visible_vector_iterator i) const
    {
      return position - i.position;
    }
  
  bool operator== (const visible_vector_iterator& i) const
    {
      return position == i.position;
    }
  bool operator!= (const visible_vector_iterator& i) const
    {
      return position != i.position;
    }
  
  // Required for animation
  virtual void touchAllPointers() const
    {
      if (container != 0)
	{
	  if (position != (container->end()))
	    touch (*position, AlgAE::AnyDir);
	}
    }

  virtual void writeText(ostream& out) const
    {
      out << " ";
    }
  
};




//////////////////////////////////////////////////////////////



template <class T>
class VisibleVector: public Visible, public Indexable
{
private:
  Vector<T> v;
public:
  
  typedef visible_vector_iterator<T> iterator;
  typedef visible_vector_const_iterator<T> const_iterator;
  typedef Vector<T>::size_type size_type;
  typedef T value_type;
  
  VisibleVector(AlgAE::Color color, bool vertical): Visible(color, vertical) {}
  
  VisibleVector (AlgAE::Color color, bool vertical,
                 size_type n, const T& value = T())
    : v(n, value), Visible(color, vertical) {}
  
  VisibleVector (const VisibleVector& x)
    : v(x.v), Visible(x.color(), x.vertical())  {}
  
  VisibleVector(AlgAE::Color color, bool vertical,
                const_iterator first, const_iterator last)
    : v(first.position, last.position), Visible(color, vertical)  {}
  
  ~VisibleVector() {}
  
  VisibleVector& operator=(const VisibleVector<T>& x)
    {
      v = x.v;
      return *this;
    }
  
  iterator begin() {return iterator(v.begin(), &v);}
  iterator end()   {return iterator(v.end(), &v);}

  const_iterator begin() const {return const_iterator(v.begin(), &v);}
  const_iterator end()   const {return const_iterator(v.end(), &v);}
  


  void swap(VisibleVector& x)   {v.swap(x.v);}

  // Size and capacity
  size_type size() const        {return v.size();}
  size_type max_size() const    {return v.max_size();}
  size_type capacity() const    {return v.capacity();}
  
  bool empty() const            {return v.empty();}
  
  void reserve(size_type n)     {v.reserve(n);}
  void resize(size_type n)      {resize(n, T());}
  void resize(size_type n, T c) {v.resize(n, c);}

  // Access
  
  T& operator[](size_type n)    {return v[n];}
  const T& operator[](size_type n) const  {return v[n];}
  
  T& front()                    {return v.front();}
  const T& front() const        {return v.front();}
  
  T& back()                     {return v.back();}
  const T& back() const         {return v.back();}
  
  
  // Insertion
  void push_back(const T& x)    {v.push_back (x);}
  
  iterator insert(iterator pos,
                  const T& x)
    {return iterator(v.insert(pos.position, x), &v);}
  
  void insert (iterator pos,
               const_iterator first,
               const_iterator last)
    {v.insert(pos.position, first.position, last.position);}
  
  void insert (iterator pos,
               size_type n, const T& x)
    {v.insert(pos.position, n, x);}
  
  
  // Removal
  void pop_back()               {v.pop_back();}
  
  void erase(iterator position) {v.erase(position.position);}
  
  void erase(iterator first, iterator last)
    {v.erase (first.position, last.position);}

  void clear()
    {v.clear();}
  
  



  ////////////////////////////////////////////////
  // Required for Indexable
  
  virtual Visible* elementAt (int index) const
    {
      if ((index >= 0) && (index < size()))
	{
	  const Visible& x = operator[](index);
	  return (Visible*)(&x);
	}
      else
	return 0;
    }
  
  ////////////////////////////////////////////////
  // Required for animation
  virtual void touchAllComponents() const
    {
      for (const_iterator i = begin(); i != end(); ++i)
	touch (*i);
    }
  
  virtual void writeText (STD ostream &) const
    {
    }
};

#undef Vector

#endif