1

/* $Id$ */

     2

     3

/** @file oldpool.h */

     4

     5

#ifndef OLDPOOL_H

     6

#define OLDPOOL_H

     7

     8

/* The function that is called after a new block is added

     9

     start_item is the first item of the new made block */

    10

typedef void OldMemoryPoolNewBlock(uint start_item);

    11

/* The function that is called before a block is cleaned up */

    12

typedef void OldMemoryPoolCleanBlock(uint start_item, uint end_item);

    13

    14

/**

    15

 * Stuff for dynamic vehicles. Use the wrappers to access the OldMemoryPool

    16

 *  please try to avoid manual calls!

    17

 */

    18

struct OldMemoryPoolBase {

    19

	void CleanPool();

    20

	bool AddBlockToPool();

    21

	bool AddBlockIfNeeded(uint index);

    22

    23

protected:

    24

	OldMemoryPoolBase(const char *name, uint max_blocks, uint block_size_bits, uint item_size,

    25

				OldMemoryPoolNewBlock *new_block_proc, OldMemoryPoolCleanBlock *clean_block_proc) :

    26

		name(name), max_blocks(max_blocks), block_size_bits(block_size_bits),

    27

		new_block_proc(new_block_proc), clean_block_proc(clean_block_proc), current_blocks(0),

    28

		total_items(0), cleaning_pool(false), item_size(item_size), first_free_index(0), blocks(NULL) {}

    29

    30

	const char* name;     ///< Name of the pool (just for debugging)

    31

    32

	const uint max_blocks;      ///< The max amount of blocks this pool can have

    33

	const uint block_size_bits; ///< The size of each block in bits

    34

    35

	/// Pointer to a function that is called after a new block is added

    36

	OldMemoryPoolNewBlock *new_block_proc;

    37

	/// Pointer to a function that is called to clean a block

    38

	OldMemoryPoolCleanBlock *clean_block_proc;

    39

    40

	uint current_blocks;        ///< How many blocks we have in our pool

    41

	uint total_items;           ///< How many items we now have in this pool

    42

    43

	bool cleaning_pool;         ///< Are we currently cleaning the pool?

    44

public:

    45

	const uint item_size;       ///< How many bytes one block is

    46

	uint first_free_index;      ///< The index of the first free pool item in this pool

    47

	byte **blocks;              ///< An array of blocks (one block hold all the items)

    48

    49

	/**

    50

	 * Get the size of this pool, i.e. the total number of items you

    51

	 * can put into it at the current moment; the pool might still

    52

	 * be able to increase the size of the pool.

    53

	 * @return the size of the pool

    54

	 */

    55

	inline uint GetSize() const

    56

	{

    57

		return this->total_items;

    58

	}

    59

    60

	/**

    61

	 * Can this pool allocate more blocks, i.e. is the maximum amount

    62

	 * of allocated blocks not yet reached?

    63

	 * @return the if and only if the amount of allocable blocks is

    64

	 *         less than the amount of allocated blocks.

    65

	 */

    66

	inline bool CanAllocateMoreBlocks() const

    67

	{

    68

		return this->current_blocks < this->max_blocks;

    69

	}

    70

    71

	/**

    72

	 * Get the maximum number of allocable blocks.

    73

	 * @return the numebr of blocks

    74

	 */

    75

	inline uint GetBlockCount() const

    76

	{

    77

		return this->current_blocks;

    78

	}

    79

    80

	/**

    81

	 * Get the name of this pool.

    82

	 * @return the name

    83

	 */

    84

	inline const char *GetName() const

    85

	{

    86

		return this->name;

    87

	}

    88

    89

	/**

    90

	 * Is the pool in the cleaning phase?

    91

	 * @return true if it is

    92

	 */

    93

	inline bool CleaningPool() const

    94

	{

    95

		return this->cleaning_pool;

    96

	}

    97

};

    98

    99

template <typename T>

   100

struct OldMemoryPool : public OldMemoryPoolBase {

   101

	OldMemoryPool(const char *name, uint max_blocks, uint block_size_bits, uint item_size,

   102

				OldMemoryPoolNewBlock *new_block_proc, OldMemoryPoolCleanBlock *clean_block_proc) :

   103

		OldMemoryPoolBase(name, max_blocks, block_size_bits, item_size, new_block_proc, clean_block_proc) {}

   104

   105

	/**

   106

	 * Get the pool entry at the given index.

   107

	 * @param index the index into the pool

   108

	 * @pre index < this->GetSize()

   109

	 * @return the pool entry.

   110

	 */

   111

	inline T *Get(uint index) const

   112

	{

   113

		assert(index < this->GetSize());

   114

		return (T*)(this->blocks[index >> this->block_size_bits] +

   115

				(index & ((1 << this->block_size_bits) - 1)) * this->item_size);

   116

	}

   117

};

   118

   119

/**

   120

 * Generic function to initialize a new block in a pool.

   121

 * @param start_item the first item that needs to be initialized

   122

 */

   123

template <typename T, OldMemoryPool<T> *Tpool>

   124

static void PoolNewBlock(uint start_item)

   125

{

   126

	for (T *t = Tpool->Get(start_item); t != NULL; t = (t->index + 1U < Tpool->GetSize()) ? Tpool->Get(t->index + 1U) : NULL) {

   127

		t = new (t) T();

   128

		t->index = start_item++;

   129

	}

   130

}

   131

   132

/**

   133

 * Generic function to free a new block in a pool.

   134

 * @param start_item the first item that needs to be cleaned

   135

 * @param end_item   the last item that needs to be cleaned

   136

 */

   137

template <typename T, OldMemoryPool<T> *Tpool>

   138

static void PoolCleanBlock(uint start_item, uint end_item)

   139

{

   140

	for (uint i = start_item; i <= end_item; i++) {

   141

		T *t = Tpool->Get(i);

   142

		delete t;

   143

	}

   144

}

   145

   146

   147

/**

   148

 * Generalization for all pool items that are saved in the savegame.

   149

 * It specifies all the mechanics to access the pool easily.

   150

 */

   151

template <typename T, typename Tid, OldMemoryPool<T> *Tpool>

   152

struct PoolItem {

   153

	/**

   154

	 * The pool-wide index of this object.

   155

	 */

   156

	Tid index;

   157

   158

	/**

   159

	 * We like to have the correct class destructed.

   160

	 */

   161

	virtual ~PoolItem()

   162

	{

   163

		if (this->index < Tpool->first_free_index) Tpool->first_free_index = this->index;

   164

	}

   165

   166

	/**

   167

	 * An overriden version of new that allocates memory on the pool.

   168

	 * @param size the size of the variable (unused)

   169

	 * @return the memory that is 'allocated'

   170

	 */

   171

	void *operator new(size_t size)

   172

	{

   173

		return AllocateRaw();

   174

	}

   175

   176

	/**

   177

	 * 'Free' the memory allocated by the overriden new.

   178

	 * @param p the memory to 'free'

   179

	 */

   180

	void operator delete(void *p)

   181

	{

   182

	}

   183

   184

	/**

   185

	 * An overriden version of new, so you can directly allocate a new object with

   186

	 * the correct index when one is loading the savegame.

   187

	 * @param size  the size of the variable (unused)

   188

	 * @param index the index of the object

   189

	 * @return the memory that is 'allocated'

   190

	 */

   191

	void *operator new(size_t size, int index)

   192

	{

   193

		if (!Tpool->AddBlockIfNeeded(index)) error("%s: failed loading savegame: too many %s", Tpool->GetName(), Tpool->GetName());

   194

   195

		return Tpool->Get(index);

   196

	}

   197

   198

	/**

   199

	 * 'Free' the memory allocated by the overriden new.

   200

	 * @param p     the memory to 'free'

   201

	 * @param index the original parameter given to create the memory

   202

	 */

   203

	void operator delete(void *p, int index)

   204

	{

   205

	}

   206

   207

	/**

   208

	 * An overriden version of new, so you can use the vehicle instance

   209

	 * instead of a newly allocated piece of memory.

   210

	 * @param size the size of the variable (unused)

   211

	 * @param pn   the already existing object to use as 'storage' backend

   212

	 * @return the memory that is 'allocated'

   213

	 */

   214

	void *operator new(size_t size, T *pn)

   215

	{

   216

		return pn;

   217

	}

   218

   219

	/**

   220

	 * 'Free' the memory allocated by the overriden new.

   221

	 * @param p  the memory to 'free'

   222

	 * @param pn the pointer that was given to 'new' on creation.

   223

	 */

   224

	void operator delete(void *p, T *pn)

   225

	{

   226

	}

   227

   228

private:

   229

	/**

   230

	 * Allocate a pool item; possibly allocate a new block in the pool.

   231

	 * @param first the first pool item to start searching

   232

	 * @pre first <= Tpool->GetSize()

   233

	 * @return the allocated pool item (or NULL when the pool is full).

   234

	 */

   235

	static inline T *AllocateSafeRaw(uint &first)

   236

	{

   237

		uint last_minus_one = Tpool->GetSize() - 1;

   238

   239

		for (T *t = Tpool->Get(first); t != NULL; t = (t->index < last_minus_one) ? Tpool->Get(t->index + 1U) : NULL) {

   240

			if (!t->IsValid()) {

   241

				first = t->index;

   242

				Tid index = t->index;

   243

   244

				memset(t, 0, Tpool->item_size);

   245

				t->index = index;

   246

				return t;

   247

			}

   248

		}

   249

   250

		/* Check if we can add a block to the pool */

   251

		if (Tpool->AddBlockToPool()) return AllocateRaw(first);

   252

   253

		return NULL;

   254

	}

   255

   256

protected:

   257

	/**

   258

	 * Allocate a pool item; possibly allocate a new block in the pool.

   259

	 * @return the allocated pool item (or NULL when the pool is full).

   260

	 */

   261

	static inline T *AllocateRaw()

   262

	{

   263

		return AllocateSafeRaw(Tpool->first_free_index);

   264

	}

   265

   266

	/**

   267

	 * Allocate a pool item; possibly allocate a new block in the pool.

   268

	 * @param first the first pool item to start searching

   269

	 * @return the allocated pool item (or NULL when the pool is full).

   270

	 */

   271

	static inline T *AllocateRaw(uint &first)

   272

	{

   273

		if (first >= Tpool->GetSize() && !Tpool->AddBlockToPool()) return NULL;

   274

   275

		return AllocateSafeRaw(first);

   276

	}

   277

   278

	/**

   279

	 * Are we cleaning this pool?

   280

	 * @return true if we are

   281

	 */

   282

	static inline bool CleaningPool()

   283

	{

   284

		return Tpool->CleaningPool();

   285

	}

   286

};

   287

   288

   289

#define OLD_POOL_ENUM(name, type, block_size_bits, max_blocks) \

   290

	enum { \

   291

		name##_POOL_BLOCK_SIZE_BITS = block_size_bits, \

   292

		name##_POOL_MAX_BLOCKS      = max_blocks \

   293

	};

   294

   295

   296

#define OLD_POOL_ACCESSORS(name, type) \

   297

	static inline type* Get##name(uint index) { return _##name##_pool.Get(index);  } \

   298

	static inline uint Get##name##PoolSize()  { return _##name##_pool.GetSize(); }

   299

   300

   301

#define DECLARE_OLD_POOL(name, type, block_size_bits, max_blocks) \

   302

	OLD_POOL_ENUM(name, type, block_size_bits, max_blocks) \

   303

	extern OldMemoryPool<type> _##name##_pool; \

   304

	OLD_POOL_ACCESSORS(name, type)

   305

   306

   307

#define DEFINE_OLD_POOL(name, type, new_block_proc, clean_block_proc) \

   308

	OldMemoryPool<type> _##name##_pool( \

   309

		#name, name##_POOL_MAX_BLOCKS, name##_POOL_BLOCK_SIZE_BITS, sizeof(type), \

   310

		new_block_proc, clean_block_proc);

   311

   312

#define DEFINE_OLD_POOL_GENERIC(name, type) \

   313

	OldMemoryPool<type> _##name##_pool( \

   314

		#name, name##_POOL_MAX_BLOCKS, name##_POOL_BLOCK_SIZE_BITS, sizeof(type), \

   315

		PoolNewBlock<type, &_##name##_pool>, PoolCleanBlock<type, &_##name##_pool>);

   316

   317

   318

#define STATIC_OLD_POOL(name, type, block_size_bits, max_blocks, new_block_proc, clean_block_proc) \

   319

	OLD_POOL_ENUM(name, type, block_size_bits, max_blocks) \

   320

	static DEFINE_OLD_POOL(name, type, new_block_proc, clean_block_proc) \

   321

	OLD_POOL_ACCESSORS(name, type)

   322

   323

#endif /* OLDPOOL_H */