#include "python.h"

namespace python {

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

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

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

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

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

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

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

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

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

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

   template<class T>
      seqref<T>  SeqBase<T>::iterator::operator*() {
         return seqref<T>(*seq, count);
      }

   template<class T>
      seqref<T>  SeqBase<T>::iterator::operator[] (sequence_index_type i) {
         return seqref<T>(*seq, count + i);
      }

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

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

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

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

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

   template<class T>
      int  SeqBase<T>::iterator::operator-(const iterator& other) const {
         if (seq != other.seq) 
            throw RuntimeError ("SeqBase<T>::iterator comparison error");
         return count - other.count;
      }

   // prefix ++
   template<class T> typename
      SeqBase<T>::iterator&  SeqBase<T>::iterator::operator++ () { count++; return *this;}
   // postfix ++
   template<class T> typename
      SeqBase<T>::iterator  SeqBase<T>::iterator::operator++ (int) { return iterator(seq, count++);}
   // prefix --
   template<class T> typename
      SeqBase<T>::iterator&  SeqBase<T>::iterator::operator-- () { count--; return *this;}
   // postfix --
   template<class T> typename
      SeqBase<T>::iterator SeqBase<T>::iterator::operator-- (int) { return iterator(seq, count--);}

   template<class T>
      std::string  SeqBase<T>::iterator::diagnose() const {
         std::ostringstream oss;
         //std::ostrstream oss;
         oss << "iterator diagnosis " << seq << ", " << count << std::ends;
         return std::string(oss.str());
      }
}