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

    27

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

    28

		total_items(0), blocks(NULL) {}

    29

    30

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

    31

    32

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

    33

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

    34

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

    35

    36

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

    37

	OldMemoryPoolNewBlock *new_block_proc;

    38

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

    39

	OldMemoryPoolCleanBlock *clean_block_proc;

    40

    41

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

    42

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

    43

    44

public:

    45

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

    46

    47

	inline uint GetSize()

    48

	{

    49

		return this->total_items;

    50

	}

    51

    52

	inline bool CanAllocateMoreBlocks()

    53

	{

    54

		return this->current_blocks < this->max_blocks;

    55

	}

    56

    57

	inline uint GetBlockCount()

    58

	{

    59

		return this->current_blocks;

    60

	}

    61

};

    62

    63

template <typename T>

    64

struct OldMemoryPool : public OldMemoryPoolBase {

    65

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

    66

				OldMemoryPoolNewBlock *new_block_proc, OldMemoryPoolCleanBlock *clean_block_proc) :

    67

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

    68

    69

	inline T *Get(uint index)

    70

	{

    71

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

    72

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

    73

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

    74

	}

    75

};

    76

    77

/**

    78

 * Those are the wrappers:

    79

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

    80

 *     (no need to call CreatePool!)

    81

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

    82

 *     more room

    83

 */

    84

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

    85

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

    86

    87

/**

    88

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

    89

 *

    90

 * @return Returns false if adding failed

    91

 */

    92

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

    93

    94

   129

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

   130

	enum { \

   131

		name##_POOL_BLOCK_SIZE_BITS = block_size_bits, \

   132

		name##_POOL_MAX_BLOCKS      = max_blocks \

   133

	};

   134

   135

   136

#define OLD_POOL_ACCESSORS(name, type) \

   137

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

   138

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

   139

   140

   141

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

   142

	OLD_POOL_ENUM(name, type, block_size_bits, max_blocks) \

   143

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

   144

	OLD_POOL_ACCESSORS(name, type)

   145

   146

   147

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

   148

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

   149

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

   150

		new_block_proc, clean_block_proc);

   151

   157

   158

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

   159

	OLD_POOL_ENUM(name, type, block_size_bits, max_blocks) \

   160

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

   161

	OLD_POOL_ACCESSORS(name, type)

   162

   163

#endif /* OLDPOOL_H */