39   static PoolVector *GetPools()
 
   61   virtual void CleanPool() = 0;
 
   68   PoolBase(
const PoolBase &other);
 
   82 template <
class Titem, 
typename Tindex, 
size_t Tgrowth_step, 
size_t Tmax_size, PoolType Tpool_type = PT_NORMAL, 
bool Tcache = false, 
bool Tzero = true>
 
   85   assert_compile((uint64)(Tmax_size - 1) >> 8 * 
sizeof(Tindex) == 0);
 
  111   inline Titem *
Get(
size_t index)
 
  114     return this->
data[index];
 
  134     bool ret = this->
items <= Tmax_size - n;
 
  136     this->checked = ret ? n : 0;
 
  145   template <struct Pool<Titem, Tindex, Tgrowth_step, Tmax_size, Tpool_type, Tcache, Tzero> *Tpool>
 
  155     inline void *
operator new(
size_t size)
 
  157       return Tpool->GetNew(
size);
 
  165     inline void operator delete(
void *p)
 
  167       if (p == NULL) 
return;
 
  168       Titem *pn = (Titem *)p;
 
  169       assert(pn == Tpool->Get(pn->index));
 
  170       Tpool->FreeItem(pn->index);
 
  194     inline void *
operator new(
size_t size, 
void *ptr)
 
  196       for (
size_t i = 0; i < Tpool->first_unused; i++) {
 
  203         assert(ptr != Tpool->data[i]);
 
  218       return Tpool->CanAllocate(n);
 
  227       return Tpool->cleaning;
 
  237       return Tpool->IsValidID(index);
 
  248       return Tpool->Get(index);
 
  259       return index < Tpool->first_unused ? Tpool->Get(index) : NULL;
 
  269       return Tpool->first_unused;
 
  306   void *AllocateItem(
size_t size, 
size_t index);
 
  307   void ResizeFor(
size_t index);
 
  308   size_t FindFirstFree();
 
  310   void *GetNew(
size_t size);
 
  311   void *GetNew(
size_t size, 
size_t index);
 
  313   void FreeItem(
size_t index);
 
  316 #define FOR_ALL_ITEMS_FROM(type, iter, var, start) \ 
  317   for (size_t iter = start; var = NULL, iter < type::GetPoolSize(); iter++) \ 
  318     if ((var = type::Get(iter)) != NULL) 
  320 #define FOR_ALL_ITEMS(type, iter, var) FOR_ALL_ITEMS_FROM(type, iter, var, 0)