/*
Esimerkki itse toteutetusta vektoriluokasta. Tukee alkeellisesti myös omia
   iteraattoreita.
*/

#include <iostream>
#include <cstdlib>

template <typename T>
class Vektori
{
  T* data_;
  int size_, capacity_;

  /* kutista taulukkoa kohdasta pos (poistaa elementin)*/
  void shrink(int pos) {
    for(int i=pos;i<size_;i++)
      data_[i]=data_[i+1];
    size_--;
  }

  /* kasvata taulukkoa kohdasta pos (lisää tyhjän)*/
  void grow(int pos) {
    if(size_+1 > capacity_) {
      alloc(size_+1);
    }
    for(int i=size_-1;i>=pos;i--)
      data_[i]=data_[i-1];
    size_++;
  }

  /* varaa muistia */
  void alloc(int newsize)
  {
    T* newdata=new T[newsize];
    if(data_ != NULL)
      std::memcpy(newdata, data_, sizeof(T)*size_);
    capacity_=newsize;

    if(data_!= NULL)
      delete[] data_;

    data_=newdata;
  }
 
public:
  typedef T* iterator;
  typedef const T* const_iterator;

  Vektori():size_(0),capacity_(10),data_(NULL) { alloc(10); }
  Vektori(int capacity):size_(0),capacity_(capacity),data_(NULL) { alloc(capacity); }
  ~Vektori() { delete[] data_; }
 
  iterator begin() { return data_; }
  iterator end() { return data_+size_; }
  T& operator*(iterator i) { return i; }

  const_iterator begin() const { return data_; }
  const_iterator end() const { return data_+size_; }

  const T& item(int pos) const { return data_[pos]; }

  int size(void) const { return size_; }
  int capacity(void) const { return capacity_; }

  int remove(int pos) { shrink(pos); }
  int add(T& item, int pos) { grow(pos); data_[pos]=item; }
};

int main(void)
{
  Vektori<int> i(10);
  int j=0;

  for(j=0;j<10;j++)
    i.add(j, j);

  i.remove(2); i.remove(4);

  j=666;
  i.add(j, 2);
  i.add(j, 4);
 
  for(Vektori<int>::iterator it=i.begin(); it!=i.end(); it++)
    std::cout << *it << std::endl;
 
  return 0;
}