Merge branch 'cpp-11' into save_ext

src/core/container_func.hpp

@@ -9,6 +9,11 @@
 
 /** @file container_func.hpp Functions related to use of containers. */
 
+#ifndef CONTAINER_FUNC_HPP
+#define CONTAINER_FUNC_HPP
+
+#include <iterator>
+
 template <typename C, typename UP> unsigned int container_unordered_remove_if (C &container, UP predicate) {
 	unsigned int removecount = 0;
 	for (auto it = container.begin(); it != container.end();) {
@@ -33,3 +38,5 @@ template <typename C, typename V> unsigned int container_unordered_remove(C &con
 		return v == value;
 	});
 }
+
+#endif /* CONTAINER_FUNC_HPP */

src/core/dyn_arena_alloc.hpp

@@ -0,0 +1,102 @@
+/* $Id$ */
+
+/*
+ * This file is part of OpenTTD.
+ * OpenTTD is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, version 2.
+ * OpenTTD is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ * See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with OpenTTD. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+/** @file dyn_arena_alloc.hpp Dynamic chunk-size arena allocator. */
+
+#ifndef DYN_ARENA_ALLOC_HPP
+#define DYN_ARENA_ALLOC_HPP
+
+#include <vector>
+
+/**
+ * Custom arena allocator for uniform-size allocations of a variable size.
+ * The allocation and chunk sizes may only be changed when the arena is empty.
+ */
+class DynUniformArenaAllocator {
+	std::vector<void *> used_blocks;
+
+	void *current_block = nullptr;
+	void *last_freed = nullptr;
+	size_t next_position = 0;
+
+	size_t item_size = 0;
+	size_t items_per_chunk = 0;
+
+	void NewBlock()
+	{
+		current_block = malloc(item_size * items_per_chunk);
+		assert(current_block != nullptr);
+		next_position = 0;
+		used_blocks.push_back(current_block);
+	}
+
+	public:
+	DynUniformArenaAllocator() = default;
+	DynUniformArenaAllocator(const DynUniformArenaAllocator &other) = delete;
+	DynUniformArenaAllocator& operator=(const DynUniformArenaAllocator &other) = delete;
+
+	~DynUniformArenaAllocator()
+	{
+		EmptyArena();
+	}
+
+	void EmptyArena()
+	{
+		current_block = nullptr;
+		last_freed = nullptr;
+		next_position = 0;
+		for (void *block : used_blocks) {
+			free(block);
+		}
+		used_blocks.clear();
+	}
+
+	void ResetArena()
+	{
+		EmptyArena();
+		item_size = 0;
+		items_per_chunk = 0;
+	}
+
+	void *Allocate() {
+		assert(item_size != 0);
+		if (last_freed) {
+			void *ptr = last_freed;
+			last_freed = *reinterpret_cast<void**>(ptr);
+			return ptr;
+		} else {
+			if (current_block == nullptr || next_position == items_per_chunk) {
+				NewBlock();
+			}
+			void *out = reinterpret_cast<char *>(current_block) + (item_size * next_position);
+			next_position++;
+			return out;
+		}
+	}
+
+	void Free(void *ptr) {
+		if (!ptr) return;
+		assert(current_block != nullptr);
+
+		*reinterpret_cast<void**>(ptr) = last_freed;
+		last_freed = ptr;
+	}
+
+	void SetParameters(size_t item_size, size_t items_per_chunk)
+	{
+		if (item_size < sizeof(void *)) item_size = sizeof(void *);
+		if (this->item_size == item_size && this->items_per_chunk == items_per_chunk) return;
+
+		assert(current_block == nullptr);
+		this->item_size = item_size;
+		this->items_per_chunk = items_per_chunk;
+	}
+};
+
+#endif /* DYN_ARENA_ALLOC_HPP */

src/core/pool_func.hpp

@@ -196,6 +196,7 @@ DEFINE_POOL_METHOD(void)::FreeItem(size_t index)
 DEFINE_POOL_METHOD(void)::CleanPool()
 {
 	this->cleaning = true;
+	Titem::PreCleanPool();
 	for (size_t i = 0; i < this->first_unused; i++) {
 		delete this->Get(i); // 'delete NULL;' is very valid
 	}

src/core/pool_type.hpp

@@ -286,6 +286,13 @@ struct Pool : PoolBase {
 		 * @note it's called only when !CleaningPool()
 		 */
 		static inline void PostDestructor(size_t index) { }
+
+		/**
+		 * Dummy function called before a pool is about to be cleaned.
+		 * If you want to use it, override it in PoolItem's subclass.
+		 * @note it's called only when CleaningPool()
+		 */
+		static inline void PreCleanPool() { }
 	};
 
 private: