79template <
class Titem,
typename Tindex,
size_t Tgrowth_step,
size_t Tmax_size, PoolType Tpool_type = PT_NORMAL,
bool Tcache = false,
bool Tzero = true>
82 static_assert(Tmax_size - 1 <=
MAX_UVALUE(Tindex));
86 using BitmapStorage = size_t;
87 static constexpr size_t BITMAP_SIZE = std::numeric_limits<BitmapStorage>::digits;
112 inline Titem *
Get(
size_t index)
115 return this->data[index];
125 return index < this->first_unused && this->
Get(index) !=
nullptr;
135 bool ret = this->items <= Tmax_size - n;
137 this->checked = ret ? n : 0;
148 typedef T value_type;
150 typedef T &reference;
151 typedef size_t difference_type;
152 typedef std::forward_iterator_tag iterator_category;
156 this->ValidateIndex();
159 bool operator==(
const PoolIterator &other)
const {
return this->index == other.index; }
160 bool operator!=(
const PoolIterator &other)
const {
return !(*
this == other); }
161 T * operator*()
const {
return T::Get(this->index); }
162 PoolIterator & operator++() { this->index++; this->ValidateIndex();
return *
this; }
168 while (this->index < T::GetPoolSize() && !(T::IsValidID(this->index))) this->index++;
169 if (this->index >= T::GetPoolSize()) this->index = T::Pool::MAX_SIZE;
183 bool empty() {
return this->begin() == this->end(); }
190 template <
class T,
class F>
192 typedef T value_type;
194 typedef T &reference;
195 typedef size_t difference_type;
196 typedef std::forward_iterator_tag iterator_category;
200 this->ValidateIndex();
205 T * operator*()
const {
return T::Get(this->index); }
213 while (this->index < T::GetPoolSize() && !(T::IsValidID(this->index) && this->filter(this->index))) this->index++;
214 if (this->index >= T::GetPoolSize()) this->index = T::Pool::MAX_SIZE;
222 template <
class T,
class F>
229 bool empty() {
return this->begin() == this->end(); }
236 template <struct Pool<Titem, Tindex, Tgrowth_step, Tmax_size, Tpool_type, Tcache, Tzero> *Tpool>
241 typedef struct Pool<Titem, Tindex, Tgrowth_step, Tmax_size, Tpool_type, Tcache, Tzero>
Pool;
249 inline void *
operator new(
size_t size)
251 return Tpool->GetNew(
size);
259 inline void operator delete(
void *p)
261 if (p ==
nullptr)
return;
262 Titem *pn =
static_cast<Titem *
>(p);
263 assert(pn == Tpool->Get(pn->index));
264 Tpool->FreeItem(pn->index);
287 inline void *
operator new(size_t,
void *ptr)
289 for (
size_t i = 0; i < Tpool->first_unused; i++) {
296 assert(ptr != Tpool->data[i]);
311 return Tpool->CanAllocate(n);
320 return Tpool->cleaning;
330 return Tpool->IsValidID(
index);
341 return Tpool->Get(
index);
352 return index < Tpool->first_unused ? Tpool->Get(
index) :
nullptr;
362 return Tpool->first_unused;
406 void *AllocateItem(
size_t size,
size_t index);
407 void ResizeFor(
size_t index);
408 size_t FindFirstFree();
410 void *GetNew(
size_t size);
411 void *GetNew(
size_t size,
size_t index);
413 void FreeItem(
size_t index);
Type (helpers) for enums.
#define DECLARE_ENUM_AS_BIT_SET(enum_type)
Operators to allow to work with enum as with type safe bit set in C++.
std::vector< struct PoolBase * > PoolVector
Vector of pointers to PoolBase.
PoolType
Various types of a pool.
@ PT_NONE
No pool is selected.
@ PT_NADMIN
Network admin pool.
@ PT_DATA
NewGRF or other data, that is not reset together with normal pools.
@ PT_NORMAL
Normal pool containing game objects.
@ PT_NCLIENT
Network client pools.
#define MAX_UVALUE(type)
The largest value that can be entered in a variable.
Base class for base of all pools.
const PoolType type
Type of this pool.
virtual void CleanPool()=0
Virtual method that deletes all items in the pool.
static PoolVector * GetPools()
Function used to access the vector of all pools.
PoolBase(PoolType pt)
Constructor registers this object in the pool vector.
PoolBase(const PoolBase &other)
Dummy private copy constructor to prevent compilers from copying the structure, which fails due to Ge...
Helper struct to cache 'freed' PoolItems so we do not need to allocate them again.
AllocCache * next
The next in our 'cache'.
Base class for all PoolItems.
static size_t GetPoolSize()
Returns first unused index.
Tindex index
Index of this pool item.
static void PostDestructor(size_t index)
Dummy function called after destructor of each member.
static size_t GetNumItems()
Returns number of valid items in the pool.
static bool CleaningPool()
Returns current state of pool cleaning - yes or no.
static bool IsValidID(size_t index)
Tests whether given index can be used to get valid (non-nullptr) Titem.
static Pool::IterateWrapper< Titem > Iterate(size_t from=0)
Returns an iterable ensemble of all valid Titem.
static Titem * GetIfValid(size_t index)
Returns Titem with given index.
static bool CanAllocateItem(size_t n=1)
Helper functions so we can use PoolItem::Function() instead of _poolitem_pool.Function()
static Titem * Get(size_t index)
Returns Titem with given index.
Iterator to iterate all valid T of a pool.
Iterator to iterate all valid T of a pool.
Base class for all pools.
void CleanPool() override
Virtual method that deletes all items in the pool.
Titem ** data
Pointer to array of pointers to Titem.
size_t first_free
No item with index lower than this is free (doesn't say anything about this one!)
const char *const name
Name of this pool.
std::vector< BitmapStorage > used_bitmap
Bitmap of used indices.
size_t first_unused
This and all higher indexes are free (doesn't say anything about first_unused-1 !)
size_t size
Current allocated size.
bool cleaning
True if cleaning pool (deleting all items)
size_t items
Number of used indexes (non-nullptr)
Titem * Get(size_t index)
Returns Titem with given index.
static constexpr size_t MAX_SIZE
Make template parameter accessible from outside.
AllocCache * alloc_cache
Cache of freed pointers.
bool CanAllocate(size_t n=1)
Tests whether we can allocate 'n' items.
bool IsValidID(size_t index)
Tests whether given index can be used to get valid (non-nullptr) Titem.
static const size_t NO_FREE_ITEM
Constant to indicate we can't allocate any more items.