// This file is one of a series that illustrates CheapVector (cv),
// It’s an example of an STL-like container, including
// an iterator.  It’s not efficient, but that’s not the point.
//
// This version has a separate iterator class, but no added functionality.

#ifndef CV_H_INCLUDED
#define CV_H_INCLUDED

#include <algorithm>	// copy()
#include <stdexcept>	// out_of_range
#include <string>	// to_string()

// The Cheap Vector
// It’s missing many things:
// • copy ctor
// • assignment
// • assignment from initializer_list
// • cbegin()/cend()/rbegin()/rend()/…
// • empty()
// • clear()
// • value_type

template <typename T>
class cv_iter {
  public:
    cv_iter(T *ptr_ = nullptr) : ptr(ptr_) { }
    cv_iter(const cv_iter &) = default;
    cv_iter& operator=(const cv_iter &) = default;
    cv_iter& operator++() { ++ptr; return *this; }
    cv_iter operator++(int) { const auto save = *this; ++*this; return save; }
    T& operator *() const { return *ptr; }
    bool operator==(const cv_iter &rhs) const { return ptr==rhs.ptr; }
    bool operator!=(const cv_iter &rhs) const { return !(*this==rhs); }
  private:
    T *ptr;
};

template <typename T>
class cv {
  public:
    typedef size_t size_type;
    typedef cv_iter<T> iterator;

    cv() = default;
    template <typename U>
    cv(const std::initializer_list<U> &il)
	: count(il.size()), data(new T[count]) {
	std::copy_n(il.begin(), count, data);
    }
    ~cv() { delete[] data; }
    size_type size() const { return count; }
    iterator begin() { return iterator(data); }
    iterator end() { return iterator(data+count); }
    T& operator[](size_type n) {
	if (n >= count)
	    throw std::out_of_range("Bad subscript " + std::to_string(n)
				    + ", size is " + std::to_string(count));
	return data[n];
    }
    void push_back(const T &datum) {
	T *new_data = new T[count+1];
	std::copy(data, data+count, new_data);
	delete[] data;
	data = new_data;
	data[count++] = datum;
    }
  private:
    size_type count = 0;
    T *data = nullptr;
};

#endif /* CV_H_INCLUDED */