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 name[10];        ///< 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

static inline byte *GetItemFromPool(const MemoryPool *pool, uint index)

    54

{

    55

	assert(index < pool->total_items);

    56

	return (pool->blocks[index >> pool->block_size_bits] + (index & ((1 << pool->block_size_bits) - 1)) * pool->item_size);

    57

}

    58

    59

#endif /* POOL_H */