OpenTTD Source
20240915-master-g3784a3d3d6
|
Go to the documentation of this file.
58 virtual void CleanPool() = 0;
79 template <
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);
bool IsValidID(size_t index)
Tests whether given index can be used to get valid (non-nullptr) Titem.
std::vector< struct PoolBase * > PoolVector
Vector of pointers to PoolBase.
static Titem * Get(size_t index)
Returns Titem with given index.
static Titem * GetIfValid(size_t index)
Returns Titem with given index.
Helper struct to cache 'freed' PoolItems so we do not need to allocate them again.
Tindex index
Index of this pool item.
Iterator to iterate all valid T of a pool.
static constexpr size_t MAX_SIZE
Make template parameter accessible from outside.
Base class for base of all pools.
static size_t GetPoolSize()
Returns first unused index.
AllocCache * alloc_cache
Cache of freed pointers.
size_t items
Number of used indexes (non-nullptr)
static void PostDestructor([[maybe_unused]] size_t index)
Dummy function called after destructor of each member.
Titem ** data
Pointer to array of pointers to Titem.
PoolType
Various types of a pool.
std::vector< BitmapStorage > used_bitmap
Bitmap of used indices.
bool cleaning
True if cleaning pool (deleting all items)
@ PT_NADMIN
Network admin pool.
@ PT_NONE
No pool is selected.
void CleanPool() override
Virtual method that deletes all items in the pool.
Iterator to iterate all valid T of a pool.
static const size_t NO_FREE_ITEM
Constant to indicate we can't allocate any more items.
Titem * Get(size_t index)
Returns Titem with given index.
@ PT_NCLIENT
Network client pools.
size_t first_free
No item with index lower than this is free (doesn't say anything about this one!)
static Pool::IterateWrapper< Titem > Iterate(size_t from=0)
Returns an iterable ensemble of all valid Titem.
@ PT_NORMAL
Normal pool containing game objects.
Base class for all pools.
size_t size
Current allocated size.
@ PT_DATA
NewGRF or other data, that is not reset together with normal pools.
static size_t GetNumItems()
Returns number of valid items in the pool.
AllocCache * next
The next in our 'cache'.
static bool CleaningPool()
Returns current state of pool cleaning - yes or no.
static bool CanAllocateItem(size_t n=1)
Helper functions so we can use PoolItem::Function() instead of _poolitem_pool.Function()
#define MAX_UVALUE(type)
The largest value that can be entered in a variable.
DECLARE_ENUM_AS_BIT_SET(GenderEthnicity) enum CompanyManagerFaceVariable
Bitgroups of the CompanyManagerFace variable.
PoolBase(PoolType pt)
Constructor registers this object in the pool vector.
const char *const name
Name of this pool.
size_t first_unused
This and all higher indexes are free (doesn't say anything about first_unused-1 !)
static bool IsValidID(size_t index)
Tests whether given index can be used to get valid (non-nullptr) Titem.
const PoolType type
Type of this pool.
Base class for all PoolItems.
static PoolVector * GetPools()
Function used to access the vector of all pools.
bool CanAllocate(size_t n=1)
Tests whether we can allocate 'n' items.