chunk_allocator

#pragma once
#include <vector>

template<typename T>
struct SimpleDestructableTrivialy
{
	static constexpr bool value = std::is_trivially_destructible<T>::value;
};
template<typename T, bool = SimpleDestructableTrivialy<T>::value>
class SimpleDestroy
{
public:
	void destroyElements(T* p, std::size_t T_per_page);
};
template<typename T>
class SimpleDestroy<T, true>
{
public:
	void destroyElements(T* p, std::size_t T_per_page) {}
};
template<typename T>
class SimpleDestroy<T, false>
{
public:
	void destroyElements(T* p, std::size_t T_per_page)
	{
		for (size_t pos = T_per_page; pos > 0; --pos)
			p[pos - 1].~T();
	}
};

template <size_t T_per_page>
class LinearGrowth
{
public:
	size_t operator++()
	{
		return T_per_page;
	}

	size_t operator++(int)
	{
		return T_per_page;
	}

	operator size_t()
	{
		return T_per_page;
	}

	size_t operator--()
	{
		return T_per_page;
	}

	size_t operator--(int)
	{
		return T_per_page;
	}
};

template <class T, typename GrowthPolicy = LinearGrowth<200>>
class Allocator {
	size_t pool_size = sizeof(T);
	std::vector<T*> pools;

	size_t next_pos;

	GrowthPolicy policy;
	SimpleDestroy<T> destroyer;

	void alloc_pool() {
		next_pos = 0;
		pool_size *= ++policy;
		void *temp = operator new(policy);
		pools.push_back(static_cast<T *>(temp));
	}
public:
	Allocator() {
		alloc_pool();
	}

	template <typename ... ArgsType>
	T* operator()(ArgsType ... args) {
		if (next_pos == policy)
		{
			alloc_pool();
		}

		T *ret = new(pools.back() + next_pos) T(std::forward<ArgsType>(args)...);
		++next_pos;
		return ret;
	}

	~Allocator() {
		while (!pools.empty())
		{
			T* p = pools.back();
			destroyer.destroyElements(p, policy--);
			operator delete(static_cast<void *>(p));
			pools.pop_back();
		}
	}
};