#include "Item.hpp"

using namespace std;

template<class T>
class ItemIteratorBase
{
    protected:
        T   *b_;
        int i_;
        mutable Item item_;

    public:
        ItemIteratorBase(T *b, int i=0): b_(b), i_(i) {}; 
        
        ItemIteratorBase<T> operator=(T *b) { b_=b; i_=0; return *this;}

        bool operator==(const ItemIteratorBase& other) const
        {
            return b_+i_ == other.b_ + i_;
        }
        bool operator==(const T *o) const
        {
            return b_+i_ == o;
        }
        bool operator!=(const T *o) const
        {
            return b_+i_ != o;
        }
        bool operator!=(const ItemIteratorBase &o) const
        {
            return b_+i_ != o.b_ + o.i_;
        }
        ItemIteratorBase operator++() 
        {
            ++i_;
            return *this;
        }
};

class ItemIterator: public ItemIteratorBase<float>
{
    public:

    ItemIterator(const ItemIteratorBase<float> &o):
        ItemIteratorBase<float>(o) {};
    ItemIterator(float *b, int i=0): ItemIteratorBase<float>(b,i)  {};

        Item* operator->() const
        {
            item_ = Item(i_, *(b_+i_));
            return &item_;
        }

        Item operator*() const
        {
            return Item(i_, *(b_+i_));
        }

};

class ConstItemIterator: public ItemIteratorBase<const float>
{
    public:

    ConstItemIterator(const ItemIteratorBase<const float> &o):
        ItemIteratorBase<const float>(o) {};
    ConstItemIterator(const float *b, int i=0): ItemIteratorBase<const float>(b,i)  {};

        const Item* operator->() const
        {
            item_ = Item(i_, *(b_+i_));
            return &item_;
        }

        const Item operator*() const
        {
            return Item(i_, *(b_+i_));
        }

};


//template <int n>
class FullPolicy
{
    protected:
         float *data_;
         int   n_;

    public:

         static const bool do_comp_test = true;

         FullPolicy(int n): n_(n) { 
             data_= new float[n];
             for (int i=0; i<n; ++i) data_[i]=.0f; 
         }
         ~FullPolicy() { delete [] data_; }
         FullPolicy(const FullPolicy &other) { 
             n_ = other.n_;
             data_ = new float[n_]; 
             for (int i=0; i<n_; ++i) data_[i] = other.data_[i];
         }

         FullPolicy& operator=(const FullPolicy &other)
         {
             if (this->data_ != other.data_)
             {
                 delete [] data_;
                 n_ = other.n_;
                 data_ = new float[n_]; 
                 for (int i=0; i<n_; ++i) data_[i] = other.data_[i];
             }
             return *this;
         }
         bool assert_compatible(FullPolicy &other) { return n_ == other.n_; }

         // makes no sense for dense vector
         // int  entries() { return n_; };

         // wie [] nur mit range-check
         float   at(int i) const {
             assert(0<= i && i<n_);
             return data_[i];
         }

         float & at(int i) {
             assert(0<= i && i<n_);
             return data_[i];
         }

         float   operator[](int i) const { return data_[i]; }
         float&  operator[](int i) { return data_[i]; }

         inline int len() const { return n_; }

         typedef float* value_iterator;
         typedef const float* const_value_iterator;
         float* begin() { return data_; }
         float* end()   { return data_+n_; }

         const float* begin()const  { return data_; }
         const float* end()  const  { return data_+n_; }

         typedef ItemIterator item_iterator;
         typedef ConstItemIterator const_item_iterator;
};