#ifndef INPLACE_BUFFER_HH

#define INPLACE_BUFFER_HH

#include "stl.hh"

#include <algorithm>

#include <array>

#include <cassert>

#include <cstdint>

#include <iterator>

#include <limits>

#include <span>

#include <type_traits>

// A run-time-sized buffer of (possibly) uninitialized data with a known

// upper-bound for the size.

// Typically objects of this type are used as local variables. Not as member

// variables of a larger class.

// This class is similar to 'static_vector<T, N>' (new name will be

// 'inplace_vector'). Except that this one leaves the initial content

// uninitialized.

// If you're unsure about the upper-bound for the size, or if that upper-bound

// is only rarely needed, then consider using 'small_buffer'.

template<typename T, size_t BUF_SIZE>

class inplace_buffer

{

	static_assert(std::is_trivially_constructible_v<T>);

	using SizeType =

	        std::conditional_t<BUF_SIZE <= std::numeric_limits<uint8_t >::max(), uint8_t,

	        std::conditional_t<BUF_SIZE <= std::numeric_limits<uint16_t>::max(), uint16_t,

	        std::conditional_t<BUF_SIZE <= std::numeric_limits<uint32_t>::max(), uint32_t,

	                                                                             uint64_t>>>;

public:

	explicit inplace_buffer(uninitialized_tag, size_t size) : sz(SizeType(size))

	{

		assert(size <= BUF_SIZE);

	}

	explicit inplace_buffer(size_t size, const T& t)

		: inplace_buffer(uninitialized_tag{}, size)

	{

		std::ranges::fill(std::span{buffer.data(), sz}, t);

	}

	template<std::ranges::forward_range Range>

	explicit inplace_buffer(const Range& range)

		: inplace_buffer(uninitialized_tag{}, std::ranges::distance(range))

	{

		std::ranges::copy(range, begin());

	}

	[[nodiscard]] explicit(false) operator std::span<T>() noexcept {

		return {buffer.data(), sz};

	}

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

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

	[[nodiscard]] T* data() noexcept { return buffer.data(); }

	[[nodiscard]] auto begin() noexcept { return buffer.begin(); }

	[[nodiscard]] auto end()   noexcept { return buffer.begin() + sz; }

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

		assert(index < sz);

		return buffer[index];

	}

	[[nodiscard]] T& front() {

		assert(!empty());

		return buffer.front();

	}

	[[nodiscard]] T& back() {

		assert(!empty());

		return buffer[sz - 1];

	}

private:

	std::array<T, BUF_SIZE> buffer;

	SizeType sz;

};

#endif