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

    12

/**

    13

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

    14

 *  please try to avoid manual calls!

    15

 */

    16

struct MemoryPool {

    17

	const char name[10];        //! Name of the pool (just for debugging)

    18

    19

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

    20

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

    21

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

    22

    23

	MemoryPoolNewBlock *new_block_proc;

    24

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

    25

    26

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

    27

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

    28

    29

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

    30

};

    31

    32

/**

    33

 * Those are the wrappers:

    34

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

    35

 *     (no need to call CreatePool!)

    36

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

    37

 *     more room

    38

 */

    39

void CleanPool(MemoryPool *array);

    40

bool AddBlockToPool(MemoryPool *array);

    41

    42

/**

    43

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

    44

 *

    45

 * @return Returns false if adding failed

    46

 */

    47

bool AddBlockIfNeeded(MemoryPool *array, uint index);

    48

    50

{

    51

	assert(index < pool->total_items);

    52

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

    53

}

    54

    55

#endif /* POOL_H */