#pragma once

#include <stddef.h>
#include <utility>

namespace std {

  template <class t>
  class vector {

    t *buffer;
    size_t buffer_length;//always positive
    size_t count;

  public:
    vector() : buffer(new t[16]), buffer_length(16), count(0) {}

    ~vector() {
      delete[] buffer;
    }

    t &operator[](size_t pos) {
      return buffer[pos];
    }

    const t &operator[](size_t pos) const {
      return buffer[pos];
    }

    t *data() {
      return buffer;
    }

    const t *data() const {
      return buffer;
    }

    size_t size() const {
      return count;
    }

    void reserve(size_t new_length) {
      if (new_length <= buffer_length)
        return;
      t *new_buffer = new t[new_length];
      for (size_t i = 0; i < count; ++i)
        new_buffer[i] = std::move(buffer[i]);
      delete[] buffer;
      buffer = new_buffer;
      buffer_length = new_length;
    }

    void push_back(t &&value) {
      if (count == buffer_length)
        reserve(count * 2);
      buffer[count++] = std::move(value);
    }

    //TODO
  };

}