#include "python.h"

namespace python {

   template<class T>
   SeqBase<T>::const_iterator::~const_iterator () {}

   template<class T>
   SeqBase<T>::const_iterator::const_iterator () {
      seq = 0;
      count = 0;
   }

   template<class T>
   SeqBase<T>::const_iterator::const_iterator (const SeqBase<T>* s, int where) 
      :seq(s), count(where) {} 

   template<class T>
   SeqBase<T>::const_iterator::const_iterator(const const_iterator& other) {
      seq = other.seq;
      count = other.count;
   }

   template<class T>
   bool SeqBase<T>::const_iterator::operator== (const const_iterator& other) {
      return (count == other.count);
   }

   template<class T>
   bool SeqBase<T>::const_iterator::operator!= (const const_iterator& other) {
      return (count != other.count);
   }

   template<class T>
   bool SeqBase<T>::const_iterator::operator< (const const_iterator& other) {
      return (count < other.count);
   }

   template<class T>
   bool SeqBase<T>::const_iterator::operator> (const const_iterator& other) {
      return (count > other.count);
   }

   template<class T>
   bool SeqBase<T>::const_iterator::operator<= (const const_iterator& other) {
      return (count <= other.count);
   }

   template<class T>
   bool SeqBase<T>::const_iterator::operator>= (const const_iterator& other) {
      return (count >= other.count);
   }

   template<class T>
   const T SeqBase<T>::const_iterator::operator*() const { 
      return seq->getItem(count);
   }

   template<class T>
   const T SeqBase<T>::const_iterator::operator[] (sequence_index_type i) const {
      return seq->getItem(count + i);
   }

   template<class T> typename
   SeqBase<T>::const_iterator::const_iterator& SeqBase<T>::const_iterator::operator=(const const_iterator& other) {
      if (this == &other) return *this;
      seq = other.seq;
      count = other.count;
      return *this;
   }

   template<class T> typename
   SeqBase<T>::const_iterator::const_iterator SeqBase<T>::const_iterator::operator+(int n) const {
      return const_iterator(seq, count + n);
   }

   template<class T> typename
   SeqBase<T>::const_iterator::const_iterator SeqBase<T>::const_iterator::operator-(int n) const {
      return const_iterator(seq, count - n);
   }

   template<class T> typename
   SeqBase<T>::const_iterator::const_iterator& SeqBase<T>::const_iterator::operator+=(int n) {
      count = count + n;
      return *this;
   }

   template<class T> typename
  SeqBase<T>::const_iterator::const_iterator& SeqBase<T>::const_iterator::operator-=(int n) {
      count = count - n;
      return *this;
   }

   template<class T>
   int SeqBase<T>::const_iterator::operator-(const const_iterator& other) const {
      if (seq != other.seq) 
         throw RuntimeError ("SeqBase<T>::const_iterator::- error");
      return count - other.count;
   }
   // prefix ++
   template<class T> typename
   SeqBase<T>::const_iterator::const_iterator& SeqBase<T>::const_iterator::operator++ () { count++; return *this;}
   // postfix ++
   template<class T> typename
   SeqBase<T>::const_iterator::const_iterator SeqBase<T>::const_iterator::operator++ (int) { return const_iterator(seq, count++);}
   // prefix --
   template<class T> typename
   SeqBase<T>::const_iterator::const_iterator& SeqBase<T>::const_iterator::operator-- () { count--; return *this;}
   // postfix --
   template<class T> typename
   SeqBase<T>::const_iterator::const_iterator SeqBase<T>::const_iterator::operator-- (int) { return const_iterator(seq, count--);}

}