//
//  vector.h
//  vector
//
//  Created by Fatlum on 3/10/18.
//  Copyright © 2018 fatlum. All rights reserved.
//

#include<iostream>
#include<initializer_list>

using namespace std;

class Vector{

public:
using value_type = double;
using size_type = size_t;
using difference_type = ptrdiff_t;
using reference = value_type&;
using const_reference = const value_type&;
using pointer = value_type*;
using const_pointer = const value_type*;

class Const_iterator{

public:
using value_type= Vector::value_type;
using difference_type = Vector::difference_type;
using reference = Vector::reference;
using pointer = Vector::pointer;
using iterator_category = std::forward_iterator_tag;

private:
pointer ptr;
const Vector* v;
public:
Const_iterator();

Const_iterator(pointer ptr, const Vector* v){
    this-> ptr = ptr;
    this-> v = v;
}

};
class Iterator{

public:
using value_type= Vector::value_type;
using difference_type = Vector::difference_type;
using reference = Vector::reference;
using pointer = Vector::pointer;
using iterator_category = std::forward_iterator_tag;

private:
pointer ptr;
const Vector* v;

public:
/*
operator Const_iterator const{
return Const_iterator{ptr,c};
}*/
Iterator();

Iterator(pointer ptr, const Vector* v){
    this-> ptr = ptr;
    this-> v = v;
}

Iterator& operator++(){//prefix
    ++ptr;
    return *this;
}

Iterator operator++(int){//postfix
    Iterator old = *this;
    ++*this;
    return old;
}

reference operator*() const{
    if ((ptr >=  v->v + v->size()) || ptr < v->v)
        throw runtime_error("[Fehlermeldung] ");
     return *ptr;
}

pointer operator->() const{
    //Validierung
    if(v->size() == 0)
	throw runtime_error("[Leer]");
    return ptr;
}

friend difference_type operator!=(Iterator& lop, Iterator& rop){
    return lop.ptr != rop.ptr;
}

friend difference_type operator==(Iterator& lop, Iterator& rop){
    return lop.ptr == rop.ptr;
}

friend difference_type operator-(Iterator& lop, Iterator& rop){
    return lop.ptr - rop.ptr;
}

};


using const_iterator = Const_iterator;
using iterator = Iterator;

private:

    size_t max_sz;
    size_t sz;
    double *v;


public:

    Vector():Vector(0){}

    Vector(size_t len){
        max_sz = len;
        v = len == 0 ? nullptr : new double[len];
        sz = 0;
    }

    Vector(initializer_list<double> l): Vector(){
        for(const auto& e: l)
            push_back(e);
    }

    Vector(const Vector& rop): Vector(){
        for(size_t i=0; i < rop.sz; i++)
            push_back(rop[i]);
    }

    ~Vector(){
        delete[] v;
    }

    Vector& operator=(const Vector& rop)
    {
        clear();
        for(size_t i=0; i < rop.sz; i++)
            push_back(rop[i]);
        return *this;

    }

    size_t size() const{
        return sz;
    }

    bool empty() const{
        return !sz;
    }

    void clear(){
        sz=0;
    }

    void reserve(size_t new_len){
        double* buf = new double[new_len];
        for(size_t i=0; i < sz; i++)
            buf[i] = v[i];
        delete[] v;
        v = buf;
        max_sz = new_len;
    }

    void shrink_to_fit(){
        if(sz == 0){
            delete[] v;
            max_sz = 0;
            sz=0;
            v = nullptr;
            return;
        }
        double *buf(new double[sz]);
        for(size_t i=0; i< sz;i++)
            buf[i] = v[i];
        delete[] v;
        v=buf;
        max_sz = sz;
    }

    void push_back(double d) {
        if(sz==max_sz)
            reserve(max_sz*2+10);
        v[sz++] = d ;
    }

    void pop_back(){
        if(empty())
            throw runtime_error("Vector leer!\n");
        sz--;
    }

    double& operator[](size_t index){
        if(index<sz)
            return v[index];
        throw runtime_error(" [Fehlermeldung]");
    }

    const double& operator[](size_t index) const{
        if(index<sz)
            return v[index];
        throw runtime_error(" [Fehlermeldung]");


    }

    friend ostream& operator<<(ostream& o, const Vector& v){
        o << '[';
        bool first{true};
        for(size_t i{0}; i < v.sz ; i++){
            if(first)
                first=false;
            else
                o << ", ";
            o << v.v[i];
        }
        return o << ']';
    }

	Iterator begin(){return Iterator{v,this};}
	Iterator end(){return Iterator{v+sz,this};}

  	/*
	const_iterator begin()const {return Const_iterator{v,this};}
	const_iterator end()const {return Const_iterator{v+sz,this};}
	*/



};