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

    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

    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

	}

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

   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

	/**

   229

	 * Is this a valid object or not?

   230

	 * @return true if and only if it is valid

   231

	 */

   232

	virtual bool IsValid() const

   233

	{

   234

		return false;

   235

	}

   236

   237

protected:

   238

	/**

   239

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

   240

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

   241

	 */

   243

	{

   244

		return AllocateRaw(Tpool->first_free_index);

   245

	}

   246

   247

	/**

   248

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

   249

	 * @param first the first pool item to start searching

   250

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

   251

	 */

   253

	{

   254

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

   255

   256

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

   257

			if (!t->IsValid()) {

   258

				first = t->index;

   259

				Tid index = t->index;

   260

   261

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

   262

				t->index = index;

   263

				return t;

   264

			}

   265

		}

   266

   267

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

   268

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

   269

   270

		return NULL;

   271

	}

   281

};

   282

   283

   284

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

   285

	enum { \

   286

		name##_POOL_BLOCK_SIZE_BITS = block_size_bits, \

   287

		name##_POOL_MAX_BLOCKS      = max_blocks \

   288

	};

   289

   290

   291

#define OLD_POOL_ACCESSORS(name, type) \

   292

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

   293

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

   294

   295

   296

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

   297

	OLD_POOL_ENUM(name, type, block_size_bits, max_blocks) \

   298

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

   299

	OLD_POOL_ACCESSORS(name, type)

   300

   301

   302

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

   303

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

   304

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

   305

		new_block_proc, clean_block_proc);

   306

   307

#define DEFINE_OLD_POOL_GENERIC(name, type) \

   308

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

   309

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

   310

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

   311

   312

   313

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

   314

	OLD_POOL_ENUM(name, type, block_size_bits, max_blocks) \

   315

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

   316

	OLD_POOL_ACCESSORS(name, type)

   317

   318

#endif /* OLDPOOL_H */