1

#ifndef POOL_H

     2

#define POOL_H

     3

     4

typedef struct MemoryPool MemoryPool;

     5

     6

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

     7

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

     8

typedef void MemoryPoolNewBlock(uint start_item);

     9

    10

/**

    11

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

    12

 *  please try to avoid manual calls!

    13

 */

    14

struct MemoryPool {

    15

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

    16

    17

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

    18

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

    19

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

    20

    21

	MemoryPoolNewBlock *new_block_proc;

    22

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

    23

    24

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

    25

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

    26

    27

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

    28

};

    29

    30

/**

    31

 * Those are the wrappers:

    32

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

    33

 *     (no need to call CreatePool!)

    34

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

    35

 *     more room

    36

 */

    37

void CleanPool(MemoryPool *array);

    38

bool AddBlockToPool(MemoryPool *array);

    39

    40

/**

    41

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

    42

 *

    43

 * @return Returns false if adding failed

    44

 */

    45

bool AddBlockIfNeeded(MemoryPool *array, uint index);

    46

    47

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

    48

{

    49

	assert(index < pool->total_items);

    50

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

    51

}

    52

    53

#endif /* POOL_H */