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), 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

public:

    44

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

    45

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

    46

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

    47

    48

	/**

    49

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

    50

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

    51

	 * be able to increase the size of the pool.

    52

	 * @return the size of the pool

    53

	 */

    54

	inline uint GetSize() const

    55

	{

    56

		return this->total_items;

    57

	}

    58

    59

	/**

    60

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

    61

	 * of allocated blocks not yet reached?

    62

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

    63

	 *         less than the amount of allocated blocks.

    64

	 */

    65

	inline bool CanAllocateMoreBlocks() const

    66

	{

    67

		return this->current_blocks < this->max_blocks;

    68

	}

    69

    70

	/**

    71

	 * Get the maximum number of allocable blocks.

    72

	 * @return the numebr of blocks

    73

	 */

    74

	inline uint GetBlockCount() const

    75

	{

    76

		return this->current_blocks;

    77

	}

    78

    79

	/**

    80

	 * Get the name of this pool.

    81

	 * @return the name

    82

	 */

    83

	inline const char *GetName() const

    84

	{

    85

		return this->name;

    86

	}

    87

};

    88

    89

template <typename T>

    90

struct OldMemoryPool : public OldMemoryPoolBase {

    91

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

    92

				OldMemoryPoolNewBlock *new_block_proc, OldMemoryPoolCleanBlock *clean_block_proc) :

    93

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

    94

    95

	/**

    96

	 * Get the pool entry at the given index.

    97

	 * @param index the index into the pool

    98

	 * @pre index < this->GetSize()

    99

	 * @return the pool entry.

   100

	 */

   101

	inline T *Get(uint index) const

   102

	{

   103

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

   104

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

   105

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

   106

	}

   107

};

   108

   109

/**

   110

 * Those are the wrappers:

   111

 *   CleanPool cleans the pool up, but you can use AddBlockToPool directly again

   112

 *     (no need to call CreatePool!)

   113

 *   AddBlockToPool adds 1 more block to the pool. Returns false if there is no

   114

 *     more room

   115

 */

   116

static inline void CleanPool(OldMemoryPoolBase *array) { array->CleanPool(); }

   117

static inline bool AddBlockToPool(OldMemoryPoolBase *array) { return array->AddBlockToPool(); }

   118

   119

/**

   120

 * Adds blocks to the pool if needed (and possible) till index fits inside the pool

   121

 *

   122

 * @return Returns false if adding failed

   123

 */

   124

static inline bool AddBlockIfNeeded(OldMemoryPoolBase *array, uint index) { return array->AddBlockIfNeeded(index); }

   125

   126

   127

/**

   128

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

   129

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

   130

 */

   131

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

   132

static void PoolNewBlock(uint start_item)

   133

{

   134

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

   135

		t = new (t) T();

   136

		t->index = start_item++;

   137

	}

   138

}

   139

   140

/**

   141

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

   142

 * This function uses QuickFree that is intended to only free memory that would be lost if the pool is freed.

   143

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

   144

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

   145

 */

   146

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

   147

static void PoolCleanBlock(uint start_item, uint end_item)

   148

{

   149

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

   150

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

   151

		if (t->IsValid()) {

   152

			t->QuickFree();

   153

		}

   154

	}

   155

}

   156

   157

   158

/**

   159

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

   160

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

   161

 */

   162

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

   163

struct PoolItem {

   164

	/**

   165

	 * The pool-wide index of this object.

   166

	 */

   167

	Tid index;

   168

   169

	/**

   170

	 * We like to have the correct class destructed.

   171

	 */

   172

	virtual ~PoolItem()

   173

	{

   174

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

   175

	}

   176

   177

	/**

   178

	 * Called on each object when the pool is being destroyed, so one

   179

	 * can free allocated memory without the need for freeing for

   180

	 * example orders.

   181

	 */

   182

	virtual void QuickFree()

   183

	{

   184

	}

   185

   186

	/**

   187

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

   188

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

   189

	 * @return the memory that is 'allocated'

   190

	 */

   191

	void *operator new(size_t size)

   192

	{

   193

		return AllocateRaw();

   194

	}

   195

   196

	/**

   197

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

   198

	 * @param p the memory to 'free'

   199

	 */

   200

	void operator delete(void *p)

   201

	{

   202

	}

   203

   204

	/**

   205

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

   206

	 * the correct index when one is loading the savegame.

   207

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

   208

	 * @param index the index of the object

   209

	 * @return the memory that is 'allocated'

   210

	 */

   211

	void *operator new(size_t size, int index)

   212

	{

   213

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

   214

   215

		return Tpool->Get(index);

   216

	}

   217

   218

	/**

   219

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

   220

	 * @param p     the memory to 'free'

   221

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

   222

	 */

   223

	void operator delete(void *p, int index)

   224

	{

   225

	}

   226

   227

	/**

   228

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

   229

	 * instead of a newly allocated piece of memory.

   230

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

   231

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

   232

	 * @return the memory that is 'allocated'

   233

	 */

   234

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

   235

	{

   236

		return pn;

   237

	}

   238

   239

	/**

   240

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

   241

	 * @param p  the memory to 'free'

   242

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

   243

	 */

   244

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

   245

	{

   246

	}

   247

   248

	/**

   249

	 * Is this a valid object or not?

   250

	 * @return true if and only if it is valid

   251

	 */

   252

	virtual bool IsValid() const

   253

	{

   254

		return false;

   255

	}

   256

   257

private:

   258

	/**

   259

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

   260

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

   261

	 */

   262

	static T *AllocateRaw()

   263

	{

   264

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

   265

			if (!t->IsValid()) {

   266

				Tpool->first_free_index = t->index;

   267

				Tid index = t->index;

   268

   269

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

   270

				t->index = index;

   271

				return t;

   272

			}

   273

		}

   274

   275

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

   276

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

   277

   278

		return NULL;

   279

	}

   280

};

   281

   282

   283

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

   284

	enum { \

   285

		name##_POOL_BLOCK_SIZE_BITS = block_size_bits, \

   286

		name##_POOL_MAX_BLOCKS      = max_blocks \

   287

	};

   288

   289

   290

#define OLD_POOL_ACCESSORS(name, type) \

   291

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

   292

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

   293

   294

   295

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

   296

	OLD_POOL_ENUM(name, type, block_size_bits, max_blocks) \

   297

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

   298

	OLD_POOL_ACCESSORS(name, type)

   299

   300

   301

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

   302

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

   303

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

   304

		new_block_proc, clean_block_proc);

   305

   306

#define DEFINE_OLD_POOL_GENERIC(name, type) \

   307

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

   308

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

   309

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

   310

   311

   312

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

   313

	OLD_POOL_ENUM(name, type, block_size_bits, max_blocks) \

   314

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

   315

	OLD_POOL_ACCESSORS(name, type)

   316

   317

#endif /* OLDPOOL_H */