1

/* $Id$ */

     2

     3

#ifndef POOL_H

     4

#define POOL_H

     5

     6

typedef struct MemoryPool MemoryPool;

     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 MemoryPoolNewBlock(uint start_item);

    11

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

    12

typedef void MemoryPoolCleanBlock(uint start_item, uint end_item);

    13

    14

/**

    15

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

    16

 *  please try to avoid manual calls!

    17

 */

    18

struct MemoryPool {

    19

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

    20

    21

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

    22

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

    23

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

    24

    25

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

    26

	MemoryPoolNewBlock *new_block_proc;

    27

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

    28

	MemoryPoolCleanBlock *clean_block_proc;

    29

    30

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

    31

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

    32

    33

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

    34

};

    35

    36

/**

    37

 * Those are the wrappers:

    38

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

    39

 *     (no need to call CreatePool!)

    40

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

    41

 *     more room

    42

 */

    43

void CleanPool(MemoryPool *array);

    44

bool AddBlockToPool(MemoryPool *array);

    45

    46

/**

    47

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

    48

 *

    49

 * @return Returns false if adding failed

    50

 */

    51

bool AddBlockIfNeeded(MemoryPool *array, uint index);

    52

    53

    54

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

    55

	enum { \

    56

		name##_POOL_BLOCK_SIZE_BITS = block_size_bits, \

    57

		name##_POOL_MAX_BLOCKS      = max_blocks \

    58

	};

    59

    60

    61

#define POOL_ACCESSORS(name, type) \

    62

	static inline type* Get##name(uint index) \

    63

	{ \

    64

		assert(index < _##name##_pool.total_items); \

    65

		return (type*)( \

    66

			_##name##_pool.blocks[index >> name##_POOL_BLOCK_SIZE_BITS] + \

    67

			(index & ((1 << name##_POOL_BLOCK_SIZE_BITS) - 1)) * sizeof(type) \

    68

		); \

    69

	} \

    70

\

    71

	static inline uint Get##name##PoolSize(void) \

    72

	{ \

    73

		return _##name##_pool.total_items; \

    74

	}

    75

    76

    77

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

    78

	POOL_ENUM(name, type, block_size_bits, max_blocks) \

    79

	extern MemoryPool _##name##_pool; \

    80

	POOL_ACCESSORS(name, type)

    81

    82

    83

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

    84

	MemoryPool _##name##_pool = { \

    85

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

    86

		new_block_proc, clean_block_proc, \

    87

		0, 0, NULL \

    88

	};

    89

    90

    91

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

    92

	POOL_ENUM(name, type, block_size_bits, max_blocks) \

    93

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

    94

	POOL_ACCESSORS(name, type)

    95

    96

#endif /* POOL_H */