cigui/include/cigui/utils/List.inl

#pragma once

#define LIST_FUNC_DEFINE(rtt) \
	template <typename T, size_t growth_scalar, size_t growth_summand> \
	rtt List<T, growth_scalar, growth_summand>

#include <cigui/core/Memory.hpp>

namespace cig
{
	LIST_FUNC_DEFINE(void)::reserve(const size_t capacity)
	{
		if (!m_Data)
		{
			m_Data = Memory::alloc<T>(capacity);
			m_Capacity = capacity;
			return;
		}
		m_Data = Memory::realloc<T>(m_Data, m_Size, capacity);
		m_Capacity = capacity;
	}

	template <typename T, size_t growth_scalar, size_t growth_summand>
	List<T, growth_scalar, growth_summand>::~List()
	{
		if (m_Data)
			Memory::dealloc<T>(m_Data);
	}


	template <typename T, size_t growth_scalar, size_t growth_summand>
	List<T, growth_scalar, growth_summand>::List(const size_t capacity)
		: m_Capacity(capacity)
	{
		reserve(capacity);
	}

	LIST_FUNC_DEFINE(void)::own(T* data, const size_t size) {
		if (m_Data)
		{
			Memory::dealloc<T>(m_Data);
		}
		m_Data = data;
		m_Size = size;
	}

	LIST_FUNC_DEFINE(void)::copy(const T* data, const size_t size) {
		m_Data = Memory::dupalloc<T>(data, size);
		m_Size = size;
	}

	LIST_FUNC_DEFINE(size_t)::size() const {
		return m_Size;
	}

	LIST_FUNC_DEFINE(T &)::operator[](const size_t index) {
		return m_Data[index];
	}
	LIST_FUNC_DEFINE(const T &)::operator[](const size_t index) const {
		return m_Data[index];
	}

	LIST_FUNC_DEFINE(void)::need(const size_t additional_size) {
		if (m_Size + additional_size > m_Capacity)
			reserve(m_Capacity + additional_size + growth_summand);
	}

	LIST_FUNC_DEFINE(bool)::empty() const {
		return m_Size == 0;
	}

	LIST_FUNC_DEFINE(void)::clear() {
		m_Size = 0;
	}

	LIST_FUNC_DEFINE(void)::push_back(const T& value) {
		if (m_Size >= m_Capacity)
			reserve(m_Capacity * growth_scalar + growth_summand);
		m_Data[m_Size++] = value;
	}

	LIST_FUNC_DEFINE(template <typename... Args> void)::emplace_back(Args&&... args) {
		if (m_Size >= m_Capacity)
			reserve(m_Capacity * growth_scalar + growth_summand);
		m_Data[m_Size++] = T(std::forward<Args>(args)...);
	}

	LIST_FUNC_DEFINE(void)::expand(const List<T>& other) {
		need(other.size());
		std::copy(other.m_Data, other.m_Data + other.size(), m_Data + m_Size);
		m_Size += other.size();
	}

	LIST_FUNC_DEFINE(template <typename Lambda> void)::iterate(Lambda&& lambda) const
	{
		for (size_t i = 0; i < m_Size; i++)
			lambda(m_Data[i]);
	}

	LIST_FUNC_DEFINE(const T*)::data() const {
		return m_Data;
	}
}

#undef LIST_FUNC_DEFINE