1

/* $Id$ */

     2

     3

/** @file oldpool.h */

     4

     5

#ifndef OLDPOOL_H

     6

#define OLDPOOL_H

     7

     8

struct OldMemoryPool;

     9

    10

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

    11

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

    12

typedef void OldMemoryPoolNewBlock(uint start_item);

    13

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

    14

typedef void OldMemoryPoolCleanBlock(uint start_item, uint end_item);

    15

    16

/**

    17

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

    18

 *  please try to avoid manual calls!

    19

 */

    20

struct OldMemoryPool {

    21

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

    22

    23

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

    24

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

    25

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

    26

    27

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

    28

	OldMemoryPoolNewBlock *new_block_proc;

    29

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

    30

	OldMemoryPoolCleanBlock *clean_block_proc;

    31

    32

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

    33

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

    34

    35

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

    36

};

    37

    38

/**

    39

 * Those are the wrappers:

    40

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

    41

 *     (no need to call CreatePool!)

    42

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

    43

 *     more room

    44

 */

    45

void CleanPool(OldMemoryPool *array);

    46

bool AddBlockToPool(OldMemoryPool *array);

    47

    48

/**

    49

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

    50

 *

    51

 * @return Returns false if adding failed

    52

 */

    53

bool AddBlockIfNeeded(OldMemoryPool *array, uint index);

    54

    55

    56

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

    57

	enum { \

    58

		name##_POOL_BLOCK_SIZE_BITS = block_size_bits, \

    59

		name##_POOL_MAX_BLOCKS      = max_blocks \

    60

	};

    61

    62

    63

#define OLD_POOL_ACCESSORS(name, type) \

    64

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

    65

	{ \

    66

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

    67

		return (type*)( \

    68

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

    69

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

    70

		); \

    71

	} \

    72

\

    73

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

    74

	{ \

    75

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

    76

	}

    77

    78

    79

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

    80

	OLD_POOL_ENUM(name, type, block_size_bits, max_blocks) \

    81

	extern OldMemoryPool _##name##_pool; \

    82

	OLD_POOL_ACCESSORS(name, type)

    83

    84

    85

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

    86

	OldMemoryPool _##name##_pool = { \

    87

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

    88

		new_block_proc, clean_block_proc, \

    89

		0, 0, NULL \

    90

	};

    91

    92

    93

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

    94

	OLD_POOL_ENUM(name, type, block_size_bits, max_blocks) \

    95

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

    96

	OLD_POOL_ACCESSORS(name, type)

    97

    98

#endif /* OLDPOOL_H */