#include "python.h"

namespace python {
   template<class T>
      seqref<T>::seqref (SeqBase<T>& seq, sequence_index_type j)
      : s(seq), offset(j), the_item (s.getItem(j)){}

   template<class T>
      seqref<T>::seqref (const seqref<T>& r)
      : s(r.s), offset(r.offset), the_item(r.the_item) {}

//   template<class T>
//      seqref<T>::~seqref() {}

   template<class T>
      seqref<T>::operator T() const { // rvalue
         return the_item;
      } 

   template<class T>
      seqref<T>& seqref<T>::operator=(const seqref<T>& rhs) { //used as lvalue
         the_item = rhs.the_item;
         s.setItem(offset, the_item);
         return *this;
      }

   template<class T>
      seqref<T>& seqref<T>::operator=(const T& ob){ // used as lvalue
         the_item = ob;
         s.setItem(offset, ob);
         return *this;
      }

   // forward everything else to the item           
   template<class T>
      PyObject* seqref<T>::ptr () const {
         return the_item.ptr();
      }

   template<class T>
      int seqref<T>::reference_count () const { // the reference count
         return the_item.reference_count();
      }

   template<class T>
      Type seqref<T>::type () const {
         return the_item.type();
      }

   template<class T>
      String seqref<T>::str () const {
         return the_item.str();
      }

   template<class T>
      String seqref<T>::repr () const {
         return the_item.repr();
      }

   template<class T>
      bool seqref<T>::has_attr (const std::string& attr_name) const {
         return the_item.has_attr(attr_name);
      }

   template<class T>
      Object seqref<T>::get_attr (const std::string& attr_name) const {
         return the_item.get_attr(attr_name);
      }

   template<class T>
      Object seqref<T>::get_item (const Object& key) const {
         return the_item.get_item(key);
      }

   template<class T>
      long seqref<T>::hash_value () const {
         return the_item.hash_value();
      }

   template<class T>
      bool seqref<T>::is_callable () const {
         return the_item.is_callable();
      }

   template<class T>
      bool seqref<T>::is_dict () const {
         return the_item.is_dict();
      }

   template<class T>
      bool seqref<T>::is_list () const {
         return the_item.is_list();
      }

   template<class T>
      bool seqref<T>::is_mapping () const {
         return the_item.is_mapping();
      }

   template<class T>
      bool seqref<T>::is_numeric () const {
         return the_item.is_numeric();
      }

   template<class T>
      bool seqref<T>::is_sequence () const {
         return the_item.is_sequence();
      }

   template<class T>
      bool seqref<T>::is_true () const {
         return the_item.is_true();
      }

   template<class T>
      bool seqref<T>::is_type (const Type& t) const {
         return the_item.is_type (t);
      }

   template<class T>
      bool seqref<T>::is_tuple() const {
         return the_item.is_tuple();
      }

   template<class T>
      bool seqref<T>::is_string() const {
         return the_item.is_string();
      }
   // Commands
   template<class T>
      void seqref<T>::set_attr (const std::string& attr_name, const Object& value) {
         the_item.set_attr(attr_name, value);
      }

   template<class T>
      void seqref<T>::del_attr (const std::string& attr_name) {
         the_item.del_attr(attr_name);
      }

   template<class T>
      void seqref<T>::del_item (const Object& key) {
         the_item.del_item(key);
      }

   template<class T>
      bool seqref<T>::operator==(const Object& o2) const {
         return the_item == o2;
      }

   template<class T>
      bool seqref<T>::operator!=(const Object& o2) const {
         return the_item != o2;               
      }

   template<class T>
      bool seqref<T>::operator>=(const Object& o2) const {
         return the_item >= o2;
      }

   template<class T>
      bool seqref<T>::operator<=(const Object& o2) const {
         return the_item <= o2;
      }

   template<class T>
      bool seqref<T>::operator<(const Object& o2) const {
         return the_item < o2;
      }

   template<class T>
      bool seqref<T>::operator>(const Object& o2) const {
         return the_item > o2;
      }
}