#ifndef DYNARRAY_HH

#define DYNARRAY_HH

// dynarray -- this models a dynamically sized array.

// This falls between a std::array and a std::vector.

//

// - Like vector the size of a dynarray is set at run-time (for std::array it's

//   set during compile-time).

// - Unlike vector the size of a dynarray can no longer change (grow/shrink)

//   after the initial construction.

//

// So qua functionality dynarray can do strictly less than a vector and strictly

// more than an array.

//

// The (only?) advantage of dynarray over vector is that the size of the

// dynarray itself is slightly smaller than the size of a vector (vector

// additionally needs to store the capacity; for dynarray size and capacity are

// always the same). (Typically on a 64-bit system: sizeof(vector)=24 and

// sizeof(dynarray)=16).

//

// This class is very similar to the array-version of std::unique_ptr (in fact

// the current implementation is based on unique_ptr<T[]>). The only addition is

// that dynarray also stores the size(*).

// (*) Technically, I think, unique_ptr<T[]> already stores the size internally

//     (typically at some offset in the allocated block). Though unfortunately

//     there's no portable way to access this size. So storing the size in the

//     dynarray class is necessary but strictly speaking redundant.

//

// The name and the interface of this class is based on the std::dynarray

// proposal for c++14. Though that proposal did not make it in c++14 and seems

// to be abandoned. Here's some (old) documentation:

//     https://www.enseignement.polytechnique.fr/informatique/INF478/docs/Cpp/en/cpp/container/dynarray.html

// This is not a full implementation of that proposal, just the easy parts

// and/or the parts that we currently need. Can easily be extended in the future

// (when needed).

#include <cassert>

#include <memory>

template<typename T>

class dynarray

{

public:

	dynarray() = default;

	dynarray(const dynarray&) = delete;

	dynarray& operator=(const dynarray&) = delete;

	~dynarray() = default;

	explicit dynarray(size_t n)

	        : m_size(n), m_data(std::make_unique<T[]>(n)) {}

	dynarray(size_t n, const T& value)

	        : m_size(n), m_data(std::make_unique<T[]>(n, value)) {}

	struct construct_from_range_tag {};

	template<typename SizedRange>

	dynarray(construct_from_range_tag, SizedRange&& range)

	        : m_size(std::size(range)), m_data(std::make_unique<T[]>(m_size)) {

		size_t i = 0;

		for (const auto& e : range) {

			m_data[i] = e;

			++i;

		}

	}

	dynarray(dynarray&& other) noexcept

		: m_size(other.m_size), m_data(std::move(other.m_data)) {

		other.m_size = 0;

		assert(!other.m_data);

	}

	dynarray& operator=(dynarray&& other) noexcept {

		if (this == &other) return *this;

		m_size = other.m_size;

		m_data = std::move(other.m_data);

		assert(!other.m_data);

		return *this;

	}

	[[nodiscard]] T& operator[](size_t i) {

		assert(i < m_size);

		return m_data[i];

	}

	[[nodiscard]] const T& operator[](size_t i) const {

		assert(i < m_size);

		return m_data[i];

	}

	[[nodiscard]] T& front() {

		assert(!empty());

		return m_data[0];

	}

	[[nodiscard]] const T& front() const {

		assert(!empty());

		return m_data[0];

	}

	[[nodiscard]] T& back() {

		assert(!empty());

		return m_data[m_size - 1];

	}

	[[nodiscard]] const T& back() const {

		assert(!empty());

		return m_data[m_size - 1];

	}

	[[nodiscard]] T* data() { return m_data.get(); }

	[[nodiscard]] const T* data() const { return m_data.get(); }

	[[nodiscard]] T* begin() { return m_data.get(); }

	[[nodiscard]] const T* begin() const { return m_data.get(); }

	[[nodiscard]] T* end() { return m_data.get() + m_size; }

	[[nodiscard]] const T* end() const { return m_data.get() + m_size; }

	[[nodiscard]] bool empty() const { return m_size == 0; }

	[[nodiscard]] size_t size() const { return m_size; }

private:

	size_t m_size = 0;

	std::unique_ptr<T[]> m_data;

};

#endif