1

/* $Id$ */

     2

     3

/** @file oldpool.h */

     4

     5

#ifndef OLDPOOL_H

     6

#define OLDPOOL_H

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

    11

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

    12

typedef void OldMemoryPoolCleanBlock(uint start_item, uint end_item);

    13

    14

/**

    15

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

    16

 *  please try to avoid manual calls!

    17

 */

    30

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

    31

    32

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

    33

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

    34

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

    35

    36

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

    37

	OldMemoryPoolNewBlock *new_block_proc;

    38

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

    39

	OldMemoryPoolCleanBlock *clean_block_proc;

    40

    41

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

    42

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

    43

    45

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

    75

};

    76

    77

/**

    78

 * Those are the wrappers:

    79

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

    80

 *     (no need to call CreatePool!)

    81

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

    82

 *     more room

    83

 */

    86

    87

/**

    88

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

    89

 *

    90

 * @return Returns false if adding failed

    91

 */

    93

    94

    95

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

    96

	enum { \

    97

		name##_POOL_BLOCK_SIZE_BITS = block_size_bits, \

    98

		name##_POOL_MAX_BLOCKS      = max_blocks \

    99

	};

   100

   101

   102

#define OLD_POOL_ACCESSORS(name, type) \

   105

   106

   107

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

   108

	OLD_POOL_ENUM(name, type, block_size_bits, max_blocks) \

   110

	OLD_POOL_ACCESSORS(name, type)

   111

   112

   113

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

   115

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

   117

   118

   119

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

   120

	OLD_POOL_ENUM(name, type, block_size_bits, max_blocks) \

   121

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

   122

	OLD_POOL_ACCESSORS(name, type)

   123

   124

#endif /* OLDPOOL_H */