#pragma once
#include <algorithm>
#include <numeric>
namespace API
{
	class Container
	{
	public:
		using iterator = int*; //aliases for generic code
		friend void swap(Container& a, Container& b) noexcept;

		Container() = default;
		explicit Container(size_t count) : _count(count), _data(new int[count]){
			std::iota(begin(), end(), 0);
		};

		explicit Container(const Container& that) { //copy ctor			
			_data = new int[that._count];
			_count = that._count;			
			std::copy(that.begin(), that.end(), _data);
		}

		Container(Container&& that) noexcept {
			_count = that._count;
			_data = that._data;
			that._data = nullptr;
			that._count = 0;
		}

		Container& operator=(Container&& that) noexcept {
			std::swap(_data, that._data);			
			std::swap(_count, that._count);			
			return *this;
		}
		
		void swap(Container& that) noexcept {
			using std::swap;
			swap(_data, that._data);
			swap(_count, that._count);
		}

		Container& operator=(const Container& that) { // copy assignment
			delete[] _data;
			_data = new int[that._count]; //overwrites an existing pointer
			_count = that._count;
			std::copy(that.begin(), that.end(), _data);
			return *this;			
		}
		
		~Container() {
			delete[] _data;
		}

		iterator begin() const noexcept { return _data; }
		iterator end() const noexcept { return _data + _count; }


	private:
		int* _data = nullptr;
		size_t _count = 0;
	};

	void swap(Container& a, Container& b) noexcept {
		a.swap(b);
	}
}