author | peter1138 |
Sun, 03 Aug 2008 17:35:08 +0000 | |
changeset 9834 | 7474149531c1 |
parent 9111 | 48ce04029fe4 |
child 10235 | 531716190738 |
permissions | -rw-r--r-- |
2186 | 1 |
/* $Id$ */ |
2 |
||
9111
48ce04029fe4
(svn r12971) -Documentation: add @file in files that missed them and add something more than whitespace as description of files that don't have a description.
rubidium
parents:
9038
diff
changeset
|
3 |
/** @file oldpool.h Base for the old pool. */ |
6351
8d0b6cce8d6d
(svn r9390) -Documentation : correct Doxygen of comments and @file inclusion. This time, brought to you by the letter O
belugas
parents:
6248
diff
changeset
|
4 |
|
5224
df36f84cbb6c
(svn r7341) - Codechange: Also rename the POOL_H define to OLDPOOL_H (forgotten in r7331).
matthijs
parents:
5216
diff
changeset
|
5 |
#ifndef OLDPOOL_H |
df36f84cbb6c
(svn r7341) - Codechange: Also rename the POOL_H define to OLDPOOL_H (forgotten in r7331).
matthijs
parents:
5216
diff
changeset
|
6 |
#define OLDPOOL_H |
1259
8d8515e3da29
(svn r1763) -Add: pool.c / pool.h: generalized routines for dynamic arrays (MemoryPools)
truelight
parents:
diff
changeset
|
7 |
|
8113
31b7784db761
(svn r11674) -Codechange: refactor some functions out of macros.h into more logical locations.
rubidium
parents:
7974
diff
changeset
|
8 |
#include "core/math_func.hpp" |
31b7784db761
(svn r11674) -Codechange: refactor some functions out of macros.h into more logical locations.
rubidium
parents:
7974
diff
changeset
|
9 |
|
1259
8d8515e3da29
(svn r1763) -Add: pool.c / pool.h: generalized routines for dynamic arrays (MemoryPools)
truelight
parents:
diff
changeset
|
10 |
/* The function that is called after a new block is added |
8d8515e3da29
(svn r1763) -Add: pool.c / pool.h: generalized routines for dynamic arrays (MemoryPools)
truelight
parents:
diff
changeset
|
11 |
start_item is the first item of the new made block */ |
5216
8bd14ee39af2
(svn r7331) - Codechange: Rename all memory pool macro's and types to "old pool", so the new pool implementation can be committed alongside it.
matthijs
parents:
4986
diff
changeset
|
12 |
typedef void OldMemoryPoolNewBlock(uint start_item); |
3585
43461f26b729
(svn r4471) - Pools: Add a facility for calling a custom function during pool block clean up.
peter1138
parents:
3173
diff
changeset
|
13 |
/* The function that is called before a block is cleaned up */ |
5216
8bd14ee39af2
(svn r7331) - Codechange: Rename all memory pool macro's and types to "old pool", so the new pool implementation can be committed alongside it.
matthijs
parents:
4986
diff
changeset
|
14 |
typedef void OldMemoryPoolCleanBlock(uint start_item, uint end_item); |
1259
8d8515e3da29
(svn r1763) -Add: pool.c / pool.h: generalized routines for dynamic arrays (MemoryPools)
truelight
parents:
diff
changeset
|
15 |
|
8d8515e3da29
(svn r1763) -Add: pool.c / pool.h: generalized routines for dynamic arrays (MemoryPools)
truelight
parents:
diff
changeset
|
16 |
/** |
5216
8bd14ee39af2
(svn r7331) - Codechange: Rename all memory pool macro's and types to "old pool", so the new pool implementation can be committed alongside it.
matthijs
parents:
4986
diff
changeset
|
17 |
* Stuff for dynamic vehicles. Use the wrappers to access the OldMemoryPool |
1259
8d8515e3da29
(svn r1763) -Add: pool.c / pool.h: generalized routines for dynamic arrays (MemoryPools)
truelight
parents:
diff
changeset
|
18 |
* please try to avoid manual calls! |
8d8515e3da29
(svn r1763) -Add: pool.c / pool.h: generalized routines for dynamic arrays (MemoryPools)
truelight
parents:
diff
changeset
|
19 |
*/ |
7375
961ab798c4b6
(svn r10744) -Codechange: make the pool a little more OO, so it can be easier in other places.
rubidium
parents:
6351
diff
changeset
|
20 |
struct OldMemoryPoolBase { |
961ab798c4b6
(svn r10744) -Codechange: make the pool a little more OO, so it can be easier in other places.
rubidium
parents:
6351
diff
changeset
|
21 |
void CleanPool(); |
961ab798c4b6
(svn r10744) -Codechange: make the pool a little more OO, so it can be easier in other places.
rubidium
parents:
6351
diff
changeset
|
22 |
bool AddBlockToPool(); |
961ab798c4b6
(svn r10744) -Codechange: make the pool a little more OO, so it can be easier in other places.
rubidium
parents:
6351
diff
changeset
|
23 |
bool AddBlockIfNeeded(uint index); |
961ab798c4b6
(svn r10744) -Codechange: make the pool a little more OO, so it can be easier in other places.
rubidium
parents:
6351
diff
changeset
|
24 |
|
961ab798c4b6
(svn r10744) -Codechange: make the pool a little more OO, so it can be easier in other places.
rubidium
parents:
6351
diff
changeset
|
25 |
protected: |
961ab798c4b6
(svn r10744) -Codechange: make the pool a little more OO, so it can be easier in other places.
rubidium
parents:
6351
diff
changeset
|
26 |
OldMemoryPoolBase(const char *name, uint max_blocks, uint block_size_bits, uint item_size, |
961ab798c4b6
(svn r10744) -Codechange: make the pool a little more OO, so it can be easier in other places.
rubidium
parents:
6351
diff
changeset
|
27 |
OldMemoryPoolNewBlock *new_block_proc, OldMemoryPoolCleanBlock *clean_block_proc) : |
7385
69832b54e5af
(svn r10754) -Fix: MorphOS does not like sizeof in the templated pool item class, so use the item size that is set in the pool.
rubidium
parents:
7383
diff
changeset
|
28 |
name(name), max_blocks(max_blocks), block_size_bits(block_size_bits), |
7375
961ab798c4b6
(svn r10744) -Codechange: make the pool a little more OO, so it can be easier in other places.
rubidium
parents:
6351
diff
changeset
|
29 |
new_block_proc(new_block_proc), clean_block_proc(clean_block_proc), current_blocks(0), |
7413
a590f7f0edb3
(svn r10799) -Fix: only calling QuickFree and not the destructor on pool cleanups might cause memory leaks due to the way C++ works.
rubidium
parents:
7402
diff
changeset
|
30 |
total_items(0), cleaning_pool(false), item_size(item_size), first_free_index(0), blocks(NULL) {} |
7375
961ab798c4b6
(svn r10744) -Codechange: make the pool a little more OO, so it can be easier in other places.
rubidium
parents:
6351
diff
changeset
|
31 |
|
5587
167d9a91ef02
(svn r8038) -Merge: the cpp branch. Effort of KUDr, Celestar, glx, Smoovius, stillunknown and pv2b.
rubidium
parents:
5475
diff
changeset
|
32 |
const char* name; ///< Name of the pool (just for debugging) |
1259
8d8515e3da29
(svn r1763) -Add: pool.c / pool.h: generalized routines for dynamic arrays (MemoryPools)
truelight
parents:
diff
changeset
|
33 |
|
7377
b6479e048c6e
(svn r10746) -Codechange: add a generic superclass for almost all pool items so we do not have to duplicate code for each of the pool item classes and use it for the station and roadstop classes.
rubidium
parents:
7376
diff
changeset
|
34 |
const uint max_blocks; ///< The max amount of blocks this pool can have |
b6479e048c6e
(svn r10746) -Codechange: add a generic superclass for almost all pool items so we do not have to duplicate code for each of the pool item classes and use it for the station and roadstop classes.
rubidium
parents:
7376
diff
changeset
|
35 |
const uint block_size_bits; ///< The size of each block in bits |
1259
8d8515e3da29
(svn r1763) -Add: pool.c / pool.h: generalized routines for dynamic arrays (MemoryPools)
truelight
parents:
diff
changeset
|
36 |
|
3173
f56ca618721b
(svn r3805) - [FS#62] Fix doxygen comments to refer to the correct parameter. (sulai)
peter1138
parents:
2436
diff
changeset
|
37 |
/// Pointer to a function that is called after a new block is added |
7383
864c7b8e1c52
(svn r10752) -Fix: apparantly const on function pointers is ignored.
rubidium
parents:
7381
diff
changeset
|
38 |
OldMemoryPoolNewBlock *new_block_proc; |
3585
43461f26b729
(svn r4471) - Pools: Add a facility for calling a custom function during pool block clean up.
peter1138
parents:
3173
diff
changeset
|
39 |
/// Pointer to a function that is called to clean a block |
7383
864c7b8e1c52
(svn r10752) -Fix: apparantly const on function pointers is ignored.
rubidium
parents:
7381
diff
changeset
|
40 |
OldMemoryPoolCleanBlock *clean_block_proc; |
1259
8d8515e3da29
(svn r1763) -Add: pool.c / pool.h: generalized routines for dynamic arrays (MemoryPools)
truelight
parents:
diff
changeset
|
41 |
|
3173
f56ca618721b
(svn r3805) - [FS#62] Fix doxygen comments to refer to the correct parameter. (sulai)
peter1138
parents:
2436
diff
changeset
|
42 |
uint current_blocks; ///< How many blocks we have in our pool |
f56ca618721b
(svn r3805) - [FS#62] Fix doxygen comments to refer to the correct parameter. (sulai)
peter1138
parents:
2436
diff
changeset
|
43 |
uint total_items; ///< How many items we now have in this pool |
f56ca618721b
(svn r3805) - [FS#62] Fix doxygen comments to refer to the correct parameter. (sulai)
peter1138
parents:
2436
diff
changeset
|
44 |
|
7413
a590f7f0edb3
(svn r10799) -Fix: only calling QuickFree and not the destructor on pool cleanups might cause memory leaks due to the way C++ works.
rubidium
parents:
7402
diff
changeset
|
45 |
bool cleaning_pool; ///< Are we currently cleaning the pool? |
7375
961ab798c4b6
(svn r10744) -Codechange: make the pool a little more OO, so it can be easier in other places.
rubidium
parents:
6351
diff
changeset
|
46 |
public: |
7385
69832b54e5af
(svn r10754) -Fix: MorphOS does not like sizeof in the templated pool item class, so use the item size that is set in the pool.
rubidium
parents:
7383
diff
changeset
|
47 |
const uint item_size; ///< How many bytes one block is |
7378
7e7a9122b7b1
(svn r10747) -Codechange: add a variable that points to some index in the pool that is not beyond the first free pool item. It does not necessarily point to the first free item, but it reduces allocation time as it does not have to start at the first item in the pool to find the first free item.
rubidium
parents:
7377
diff
changeset
|
48 |
uint first_free_index; ///< The index of the first free pool item in this pool |
3173
f56ca618721b
(svn r3805) - [FS#62] Fix doxygen comments to refer to the correct parameter. (sulai)
peter1138
parents:
2436
diff
changeset
|
49 |
byte **blocks; ///< An array of blocks (one block hold all the items) |
7375
961ab798c4b6
(svn r10744) -Codechange: make the pool a little more OO, so it can be easier in other places.
rubidium
parents:
6351
diff
changeset
|
50 |
|
7377
b6479e048c6e
(svn r10746) -Codechange: add a generic superclass for almost all pool items so we do not have to duplicate code for each of the pool item classes and use it for the station and roadstop classes.
rubidium
parents:
7376
diff
changeset
|
51 |
/** |
7974
dfe3185a62d2
(svn r11530) -Codechange: do not update Tpool->first_free_index for PoolItems allocated on stack
smatz
parents:
7496
diff
changeset
|
52 |
* Check if the index of pool item being deleted is lower than cached first_free_index |
dfe3185a62d2
(svn r11530) -Codechange: do not update Tpool->first_free_index for PoolItems allocated on stack
smatz
parents:
7496
diff
changeset
|
53 |
* @param index index of pool item |
dfe3185a62d2
(svn r11530) -Codechange: do not update Tpool->first_free_index for PoolItems allocated on stack
smatz
parents:
7496
diff
changeset
|
54 |
* @note usage of min() will result in better code on some architectures |
dfe3185a62d2
(svn r11530) -Codechange: do not update Tpool->first_free_index for PoolItems allocated on stack
smatz
parents:
7496
diff
changeset
|
55 |
*/ |
dfe3185a62d2
(svn r11530) -Codechange: do not update Tpool->first_free_index for PoolItems allocated on stack
smatz
parents:
7496
diff
changeset
|
56 |
inline void UpdateFirstFreeIndex(uint index) |
dfe3185a62d2
(svn r11530) -Codechange: do not update Tpool->first_free_index for PoolItems allocated on stack
smatz
parents:
7496
diff
changeset
|
57 |
{ |
dfe3185a62d2
(svn r11530) -Codechange: do not update Tpool->first_free_index for PoolItems allocated on stack
smatz
parents:
7496
diff
changeset
|
58 |
first_free_index = min(first_free_index, index); |
dfe3185a62d2
(svn r11530) -Codechange: do not update Tpool->first_free_index for PoolItems allocated on stack
smatz
parents:
7496
diff
changeset
|
59 |
} |
dfe3185a62d2
(svn r11530) -Codechange: do not update Tpool->first_free_index for PoolItems allocated on stack
smatz
parents:
7496
diff
changeset
|
60 |
|
dfe3185a62d2
(svn r11530) -Codechange: do not update Tpool->first_free_index for PoolItems allocated on stack
smatz
parents:
7496
diff
changeset
|
61 |
/** |
7377
b6479e048c6e
(svn r10746) -Codechange: add a generic superclass for almost all pool items so we do not have to duplicate code for each of the pool item classes and use it for the station and roadstop classes.
rubidium
parents:
7376
diff
changeset
|
62 |
* Get the size of this pool, i.e. the total number of items you |
b6479e048c6e
(svn r10746) -Codechange: add a generic superclass for almost all pool items so we do not have to duplicate code for each of the pool item classes and use it for the station and roadstop classes.
rubidium
parents:
7376
diff
changeset
|
63 |
* can put into it at the current moment; the pool might still |
b6479e048c6e
(svn r10746) -Codechange: add a generic superclass for almost all pool items so we do not have to duplicate code for each of the pool item classes and use it for the station and roadstop classes.
rubidium
parents:
7376
diff
changeset
|
64 |
* be able to increase the size of the pool. |
b6479e048c6e
(svn r10746) -Codechange: add a generic superclass for almost all pool items so we do not have to duplicate code for each of the pool item classes and use it for the station and roadstop classes.
rubidium
parents:
7376
diff
changeset
|
65 |
* @return the size of the pool |
b6479e048c6e
(svn r10746) -Codechange: add a generic superclass for almost all pool items so we do not have to duplicate code for each of the pool item classes and use it for the station and roadstop classes.
rubidium
parents:
7376
diff
changeset
|
66 |
*/ |
b6479e048c6e
(svn r10746) -Codechange: add a generic superclass for almost all pool items so we do not have to duplicate code for each of the pool item classes and use it for the station and roadstop classes.
rubidium
parents:
7376
diff
changeset
|
67 |
inline uint GetSize() const |
7375
961ab798c4b6
(svn r10744) -Codechange: make the pool a little more OO, so it can be easier in other places.
rubidium
parents:
6351
diff
changeset
|
68 |
{ |
961ab798c4b6
(svn r10744) -Codechange: make the pool a little more OO, so it can be easier in other places.
rubidium
parents:
6351
diff
changeset
|
69 |
return this->total_items; |
961ab798c4b6
(svn r10744) -Codechange: make the pool a little more OO, so it can be easier in other places.
rubidium
parents:
6351
diff
changeset
|
70 |
} |
961ab798c4b6
(svn r10744) -Codechange: make the pool a little more OO, so it can be easier in other places.
rubidium
parents:
6351
diff
changeset
|
71 |
|
7377
b6479e048c6e
(svn r10746) -Codechange: add a generic superclass for almost all pool items so we do not have to duplicate code for each of the pool item classes and use it for the station and roadstop classes.
rubidium
parents:
7376
diff
changeset
|
72 |
/** |
b6479e048c6e
(svn r10746) -Codechange: add a generic superclass for almost all pool items so we do not have to duplicate code for each of the pool item classes and use it for the station and roadstop classes.
rubidium
parents:
7376
diff
changeset
|
73 |
* Can this pool allocate more blocks, i.e. is the maximum amount |
b6479e048c6e
(svn r10746) -Codechange: add a generic superclass for almost all pool items so we do not have to duplicate code for each of the pool item classes and use it for the station and roadstop classes.
rubidium
parents:
7376
diff
changeset
|
74 |
* of allocated blocks not yet reached? |
b6479e048c6e
(svn r10746) -Codechange: add a generic superclass for almost all pool items so we do not have to duplicate code for each of the pool item classes and use it for the station and roadstop classes.
rubidium
parents:
7376
diff
changeset
|
75 |
* @return the if and only if the amount of allocable blocks is |
b6479e048c6e
(svn r10746) -Codechange: add a generic superclass for almost all pool items so we do not have to duplicate code for each of the pool item classes and use it for the station and roadstop classes.
rubidium
parents:
7376
diff
changeset
|
76 |
* less than the amount of allocated blocks. |
b6479e048c6e
(svn r10746) -Codechange: add a generic superclass for almost all pool items so we do not have to duplicate code for each of the pool item classes and use it for the station and roadstop classes.
rubidium
parents:
7376
diff
changeset
|
77 |
*/ |
b6479e048c6e
(svn r10746) -Codechange: add a generic superclass for almost all pool items so we do not have to duplicate code for each of the pool item classes and use it for the station and roadstop classes.
rubidium
parents:
7376
diff
changeset
|
78 |
inline bool CanAllocateMoreBlocks() const |
7375
961ab798c4b6
(svn r10744) -Codechange: make the pool a little more OO, so it can be easier in other places.
rubidium
parents:
6351
diff
changeset
|
79 |
{ |
961ab798c4b6
(svn r10744) -Codechange: make the pool a little more OO, so it can be easier in other places.
rubidium
parents:
6351
diff
changeset
|
80 |
return this->current_blocks < this->max_blocks; |
961ab798c4b6
(svn r10744) -Codechange: make the pool a little more OO, so it can be easier in other places.
rubidium
parents:
6351
diff
changeset
|
81 |
} |
961ab798c4b6
(svn r10744) -Codechange: make the pool a little more OO, so it can be easier in other places.
rubidium
parents:
6351
diff
changeset
|
82 |
|
7377
b6479e048c6e
(svn r10746) -Codechange: add a generic superclass for almost all pool items so we do not have to duplicate code for each of the pool item classes and use it for the station and roadstop classes.
rubidium
parents:
7376
diff
changeset
|
83 |
/** |
b6479e048c6e
(svn r10746) -Codechange: add a generic superclass for almost all pool items so we do not have to duplicate code for each of the pool item classes and use it for the station and roadstop classes.
rubidium
parents:
7376
diff
changeset
|
84 |
* Get the maximum number of allocable blocks. |
b6479e048c6e
(svn r10746) -Codechange: add a generic superclass for almost all pool items so we do not have to duplicate code for each of the pool item classes and use it for the station and roadstop classes.
rubidium
parents:
7376
diff
changeset
|
85 |
* @return the numebr of blocks |
b6479e048c6e
(svn r10746) -Codechange: add a generic superclass for almost all pool items so we do not have to duplicate code for each of the pool item classes and use it for the station and roadstop classes.
rubidium
parents:
7376
diff
changeset
|
86 |
*/ |
b6479e048c6e
(svn r10746) -Codechange: add a generic superclass for almost all pool items so we do not have to duplicate code for each of the pool item classes and use it for the station and roadstop classes.
rubidium
parents:
7376
diff
changeset
|
87 |
inline uint GetBlockCount() const |
7375
961ab798c4b6
(svn r10744) -Codechange: make the pool a little more OO, so it can be easier in other places.
rubidium
parents:
6351
diff
changeset
|
88 |
{ |
961ab798c4b6
(svn r10744) -Codechange: make the pool a little more OO, so it can be easier in other places.
rubidium
parents:
6351
diff
changeset
|
89 |
return this->current_blocks; |
961ab798c4b6
(svn r10744) -Codechange: make the pool a little more OO, so it can be easier in other places.
rubidium
parents:
6351
diff
changeset
|
90 |
} |
7377
b6479e048c6e
(svn r10746) -Codechange: add a generic superclass for almost all pool items so we do not have to duplicate code for each of the pool item classes and use it for the station and roadstop classes.
rubidium
parents:
7376
diff
changeset
|
91 |
|
b6479e048c6e
(svn r10746) -Codechange: add a generic superclass for almost all pool items so we do not have to duplicate code for each of the pool item classes and use it for the station and roadstop classes.
rubidium
parents:
7376
diff
changeset
|
92 |
/** |
b6479e048c6e
(svn r10746) -Codechange: add a generic superclass for almost all pool items so we do not have to duplicate code for each of the pool item classes and use it for the station and roadstop classes.
rubidium
parents:
7376
diff
changeset
|
93 |
* Get the name of this pool. |
b6479e048c6e
(svn r10746) -Codechange: add a generic superclass for almost all pool items so we do not have to duplicate code for each of the pool item classes and use it for the station and roadstop classes.
rubidium
parents:
7376
diff
changeset
|
94 |
* @return the name |
b6479e048c6e
(svn r10746) -Codechange: add a generic superclass for almost all pool items so we do not have to duplicate code for each of the pool item classes and use it for the station and roadstop classes.
rubidium
parents:
7376
diff
changeset
|
95 |
*/ |
b6479e048c6e
(svn r10746) -Codechange: add a generic superclass for almost all pool items so we do not have to duplicate code for each of the pool item classes and use it for the station and roadstop classes.
rubidium
parents:
7376
diff
changeset
|
96 |
inline const char *GetName() const |
b6479e048c6e
(svn r10746) -Codechange: add a generic superclass for almost all pool items so we do not have to duplicate code for each of the pool item classes and use it for the station and roadstop classes.
rubidium
parents:
7376
diff
changeset
|
97 |
{ |
b6479e048c6e
(svn r10746) -Codechange: add a generic superclass for almost all pool items so we do not have to duplicate code for each of the pool item classes and use it for the station and roadstop classes.
rubidium
parents:
7376
diff
changeset
|
98 |
return this->name; |
b6479e048c6e
(svn r10746) -Codechange: add a generic superclass for almost all pool items so we do not have to duplicate code for each of the pool item classes and use it for the station and roadstop classes.
rubidium
parents:
7376
diff
changeset
|
99 |
} |
7413
a590f7f0edb3
(svn r10799) -Fix: only calling QuickFree and not the destructor on pool cleanups might cause memory leaks due to the way C++ works.
rubidium
parents:
7402
diff
changeset
|
100 |
|
a590f7f0edb3
(svn r10799) -Fix: only calling QuickFree and not the destructor on pool cleanups might cause memory leaks due to the way C++ works.
rubidium
parents:
7402
diff
changeset
|
101 |
/** |
a590f7f0edb3
(svn r10799) -Fix: only calling QuickFree and not the destructor on pool cleanups might cause memory leaks due to the way C++ works.
rubidium
parents:
7402
diff
changeset
|
102 |
* Is the pool in the cleaning phase? |
a590f7f0edb3
(svn r10799) -Fix: only calling QuickFree and not the destructor on pool cleanups might cause memory leaks due to the way C++ works.
rubidium
parents:
7402
diff
changeset
|
103 |
* @return true if it is |
a590f7f0edb3
(svn r10799) -Fix: only calling QuickFree and not the destructor on pool cleanups might cause memory leaks due to the way C++ works.
rubidium
parents:
7402
diff
changeset
|
104 |
*/ |
a590f7f0edb3
(svn r10799) -Fix: only calling QuickFree and not the destructor on pool cleanups might cause memory leaks due to the way C++ works.
rubidium
parents:
7402
diff
changeset
|
105 |
inline bool CleaningPool() const |
a590f7f0edb3
(svn r10799) -Fix: only calling QuickFree and not the destructor on pool cleanups might cause memory leaks due to the way C++ works.
rubidium
parents:
7402
diff
changeset
|
106 |
{ |
a590f7f0edb3
(svn r10799) -Fix: only calling QuickFree and not the destructor on pool cleanups might cause memory leaks due to the way C++ works.
rubidium
parents:
7402
diff
changeset
|
107 |
return this->cleaning_pool; |
a590f7f0edb3
(svn r10799) -Fix: only calling QuickFree and not the destructor on pool cleanups might cause memory leaks due to the way C++ works.
rubidium
parents:
7402
diff
changeset
|
108 |
} |
7375
961ab798c4b6
(svn r10744) -Codechange: make the pool a little more OO, so it can be easier in other places.
rubidium
parents:
6351
diff
changeset
|
109 |
}; |
961ab798c4b6
(svn r10744) -Codechange: make the pool a little more OO, so it can be easier in other places.
rubidium
parents:
6351
diff
changeset
|
110 |
|
961ab798c4b6
(svn r10744) -Codechange: make the pool a little more OO, so it can be easier in other places.
rubidium
parents:
6351
diff
changeset
|
111 |
template <typename T> |
961ab798c4b6
(svn r10744) -Codechange: make the pool a little more OO, so it can be easier in other places.
rubidium
parents:
6351
diff
changeset
|
112 |
struct OldMemoryPool : public OldMemoryPoolBase { |
961ab798c4b6
(svn r10744) -Codechange: make the pool a little more OO, so it can be easier in other places.
rubidium
parents:
6351
diff
changeset
|
113 |
OldMemoryPool(const char *name, uint max_blocks, uint block_size_bits, uint item_size, |
961ab798c4b6
(svn r10744) -Codechange: make the pool a little more OO, so it can be easier in other places.
rubidium
parents:
6351
diff
changeset
|
114 |
OldMemoryPoolNewBlock *new_block_proc, OldMemoryPoolCleanBlock *clean_block_proc) : |
961ab798c4b6
(svn r10744) -Codechange: make the pool a little more OO, so it can be easier in other places.
rubidium
parents:
6351
diff
changeset
|
115 |
OldMemoryPoolBase(name, max_blocks, block_size_bits, item_size, new_block_proc, clean_block_proc) {} |
961ab798c4b6
(svn r10744) -Codechange: make the pool a little more OO, so it can be easier in other places.
rubidium
parents:
6351
diff
changeset
|
116 |
|
7377
b6479e048c6e
(svn r10746) -Codechange: add a generic superclass for almost all pool items so we do not have to duplicate code for each of the pool item classes and use it for the station and roadstop classes.
rubidium
parents:
7376
diff
changeset
|
117 |
/** |
b6479e048c6e
(svn r10746) -Codechange: add a generic superclass for almost all pool items so we do not have to duplicate code for each of the pool item classes and use it for the station and roadstop classes.
rubidium
parents:
7376
diff
changeset
|
118 |
* Get the pool entry at the given index. |
b6479e048c6e
(svn r10746) -Codechange: add a generic superclass for almost all pool items so we do not have to duplicate code for each of the pool item classes and use it for the station and roadstop classes.
rubidium
parents:
7376
diff
changeset
|
119 |
* @param index the index into the pool |
b6479e048c6e
(svn r10746) -Codechange: add a generic superclass for almost all pool items so we do not have to duplicate code for each of the pool item classes and use it for the station and roadstop classes.
rubidium
parents:
7376
diff
changeset
|
120 |
* @pre index < this->GetSize() |
b6479e048c6e
(svn r10746) -Codechange: add a generic superclass for almost all pool items so we do not have to duplicate code for each of the pool item classes and use it for the station and roadstop classes.
rubidium
parents:
7376
diff
changeset
|
121 |
* @return the pool entry. |
b6479e048c6e
(svn r10746) -Codechange: add a generic superclass for almost all pool items so we do not have to duplicate code for each of the pool item classes and use it for the station and roadstop classes.
rubidium
parents:
7376
diff
changeset
|
122 |
*/ |
b6479e048c6e
(svn r10746) -Codechange: add a generic superclass for almost all pool items so we do not have to duplicate code for each of the pool item classes and use it for the station and roadstop classes.
rubidium
parents:
7376
diff
changeset
|
123 |
inline T *Get(uint index) const |
7375
961ab798c4b6
(svn r10744) -Codechange: make the pool a little more OO, so it can be easier in other places.
rubidium
parents:
6351
diff
changeset
|
124 |
{ |
961ab798c4b6
(svn r10744) -Codechange: make the pool a little more OO, so it can be easier in other places.
rubidium
parents:
6351
diff
changeset
|
125 |
assert(index < this->GetSize()); |
961ab798c4b6
(svn r10744) -Codechange: make the pool a little more OO, so it can be easier in other places.
rubidium
parents:
6351
diff
changeset
|
126 |
return (T*)(this->blocks[index >> this->block_size_bits] + |
7385
69832b54e5af
(svn r10754) -Fix: MorphOS does not like sizeof in the templated pool item class, so use the item size that is set in the pool.
rubidium
parents:
7383
diff
changeset
|
127 |
(index & ((1 << this->block_size_bits) - 1)) * this->item_size); |
7375
961ab798c4b6
(svn r10744) -Codechange: make the pool a little more OO, so it can be easier in other places.
rubidium
parents:
6351
diff
changeset
|
128 |
} |
1259
8d8515e3da29
(svn r1763) -Add: pool.c / pool.h: generalized routines for dynamic arrays (MemoryPools)
truelight
parents:
diff
changeset
|
129 |
}; |
8d8515e3da29
(svn r1763) -Add: pool.c / pool.h: generalized routines for dynamic arrays (MemoryPools)
truelight
parents:
diff
changeset
|
130 |
|
8d8515e3da29
(svn r1763) -Add: pool.c / pool.h: generalized routines for dynamic arrays (MemoryPools)
truelight
parents:
diff
changeset
|
131 |
/** |
7376
066596e64cd5
(svn r10745) -Codechange: generalize the pool cleanup/initialize functions for stations (in such a manner that they can be used for other pools too).
rubidium
parents:
7375
diff
changeset
|
132 |
* Generic function to initialize a new block in a pool. |
066596e64cd5
(svn r10745) -Codechange: generalize the pool cleanup/initialize functions for stations (in such a manner that they can be used for other pools too).
rubidium
parents:
7375
diff
changeset
|
133 |
* @param start_item the first item that needs to be initialized |
066596e64cd5
(svn r10745) -Codechange: generalize the pool cleanup/initialize functions for stations (in such a manner that they can be used for other pools too).
rubidium
parents:
7375
diff
changeset
|
134 |
*/ |
066596e64cd5
(svn r10745) -Codechange: generalize the pool cleanup/initialize functions for stations (in such a manner that they can be used for other pools too).
rubidium
parents:
7375
diff
changeset
|
135 |
template <typename T, OldMemoryPool<T> *Tpool> |
066596e64cd5
(svn r10745) -Codechange: generalize the pool cleanup/initialize functions for stations (in such a manner that they can be used for other pools too).
rubidium
parents:
7375
diff
changeset
|
136 |
static void PoolNewBlock(uint start_item) |
066596e64cd5
(svn r10745) -Codechange: generalize the pool cleanup/initialize functions for stations (in such a manner that they can be used for other pools too).
rubidium
parents:
7375
diff
changeset
|
137 |
{ |
066596e64cd5
(svn r10745) -Codechange: generalize the pool cleanup/initialize functions for stations (in such a manner that they can be used for other pools too).
rubidium
parents:
7375
diff
changeset
|
138 |
for (T *t = Tpool->Get(start_item); t != NULL; t = (t->index + 1U < Tpool->GetSize()) ? Tpool->Get(t->index + 1U) : NULL) { |
7377
b6479e048c6e
(svn r10746) -Codechange: add a generic superclass for almost all pool items so we do not have to duplicate code for each of the pool item classes and use it for the station and roadstop classes.
rubidium
parents:
7376
diff
changeset
|
139 |
t = new (t) T(); |
7376
066596e64cd5
(svn r10745) -Codechange: generalize the pool cleanup/initialize functions for stations (in such a manner that they can be used for other pools too).
rubidium
parents:
7375
diff
changeset
|
140 |
t->index = start_item++; |
066596e64cd5
(svn r10745) -Codechange: generalize the pool cleanup/initialize functions for stations (in such a manner that they can be used for other pools too).
rubidium
parents:
7375
diff
changeset
|
141 |
} |
066596e64cd5
(svn r10745) -Codechange: generalize the pool cleanup/initialize functions for stations (in such a manner that they can be used for other pools too).
rubidium
parents:
7375
diff
changeset
|
142 |
} |
066596e64cd5
(svn r10745) -Codechange: generalize the pool cleanup/initialize functions for stations (in such a manner that they can be used for other pools too).
rubidium
parents:
7375
diff
changeset
|
143 |
|
066596e64cd5
(svn r10745) -Codechange: generalize the pool cleanup/initialize functions for stations (in such a manner that they can be used for other pools too).
rubidium
parents:
7375
diff
changeset
|
144 |
/** |
066596e64cd5
(svn r10745) -Codechange: generalize the pool cleanup/initialize functions for stations (in such a manner that they can be used for other pools too).
rubidium
parents:
7375
diff
changeset
|
145 |
* Generic function to free a new block in a pool. |
066596e64cd5
(svn r10745) -Codechange: generalize the pool cleanup/initialize functions for stations (in such a manner that they can be used for other pools too).
rubidium
parents:
7375
diff
changeset
|
146 |
* @param start_item the first item that needs to be cleaned |
066596e64cd5
(svn r10745) -Codechange: generalize the pool cleanup/initialize functions for stations (in such a manner that they can be used for other pools too).
rubidium
parents:
7375
diff
changeset
|
147 |
* @param end_item the last item that needs to be cleaned |
066596e64cd5
(svn r10745) -Codechange: generalize the pool cleanup/initialize functions for stations (in such a manner that they can be used for other pools too).
rubidium
parents:
7375
diff
changeset
|
148 |
*/ |
066596e64cd5
(svn r10745) -Codechange: generalize the pool cleanup/initialize functions for stations (in such a manner that they can be used for other pools too).
rubidium
parents:
7375
diff
changeset
|
149 |
template <typename T, OldMemoryPool<T> *Tpool> |
066596e64cd5
(svn r10745) -Codechange: generalize the pool cleanup/initialize functions for stations (in such a manner that they can be used for other pools too).
rubidium
parents:
7375
diff
changeset
|
150 |
static void PoolCleanBlock(uint start_item, uint end_item) |
066596e64cd5
(svn r10745) -Codechange: generalize the pool cleanup/initialize functions for stations (in such a manner that they can be used for other pools too).
rubidium
parents:
7375
diff
changeset
|
151 |
{ |
066596e64cd5
(svn r10745) -Codechange: generalize the pool cleanup/initialize functions for stations (in such a manner that they can be used for other pools too).
rubidium
parents:
7375
diff
changeset
|
152 |
for (uint i = start_item; i <= end_item; i++) { |
066596e64cd5
(svn r10745) -Codechange: generalize the pool cleanup/initialize functions for stations (in such a manner that they can be used for other pools too).
rubidium
parents:
7375
diff
changeset
|
153 |
T *t = Tpool->Get(i); |
7413
a590f7f0edb3
(svn r10799) -Fix: only calling QuickFree and not the destructor on pool cleanups might cause memory leaks due to the way C++ works.
rubidium
parents:
7402
diff
changeset
|
154 |
delete t; |
7376
066596e64cd5
(svn r10745) -Codechange: generalize the pool cleanup/initialize functions for stations (in such a manner that they can be used for other pools too).
rubidium
parents:
7375
diff
changeset
|
155 |
} |
066596e64cd5
(svn r10745) -Codechange: generalize the pool cleanup/initialize functions for stations (in such a manner that they can be used for other pools too).
rubidium
parents:
7375
diff
changeset
|
156 |
} |
066596e64cd5
(svn r10745) -Codechange: generalize the pool cleanup/initialize functions for stations (in such a manner that they can be used for other pools too).
rubidium
parents:
7375
diff
changeset
|
157 |
|
066596e64cd5
(svn r10745) -Codechange: generalize the pool cleanup/initialize functions for stations (in such a manner that they can be used for other pools too).
rubidium
parents:
7375
diff
changeset
|
158 |
|
7377
b6479e048c6e
(svn r10746) -Codechange: add a generic superclass for almost all pool items so we do not have to duplicate code for each of the pool item classes and use it for the station and roadstop classes.
rubidium
parents:
7376
diff
changeset
|
159 |
/** |
b6479e048c6e
(svn r10746) -Codechange: add a generic superclass for almost all pool items so we do not have to duplicate code for each of the pool item classes and use it for the station and roadstop classes.
rubidium
parents:
7376
diff
changeset
|
160 |
* Generalization for all pool items that are saved in the savegame. |
b6479e048c6e
(svn r10746) -Codechange: add a generic superclass for almost all pool items so we do not have to duplicate code for each of the pool item classes and use it for the station and roadstop classes.
rubidium
parents:
7376
diff
changeset
|
161 |
* It specifies all the mechanics to access the pool easily. |
b6479e048c6e
(svn r10746) -Codechange: add a generic superclass for almost all pool items so we do not have to duplicate code for each of the pool item classes and use it for the station and roadstop classes.
rubidium
parents:
7376
diff
changeset
|
162 |
*/ |
b6479e048c6e
(svn r10746) -Codechange: add a generic superclass for almost all pool items so we do not have to duplicate code for each of the pool item classes and use it for the station and roadstop classes.
rubidium
parents:
7376
diff
changeset
|
163 |
template <typename T, typename Tid, OldMemoryPool<T> *Tpool> |
b6479e048c6e
(svn r10746) -Codechange: add a generic superclass for almost all pool items so we do not have to duplicate code for each of the pool item classes and use it for the station and roadstop classes.
rubidium
parents:
7376
diff
changeset
|
164 |
struct PoolItem { |
b6479e048c6e
(svn r10746) -Codechange: add a generic superclass for almost all pool items so we do not have to duplicate code for each of the pool item classes and use it for the station and roadstop classes.
rubidium
parents:
7376
diff
changeset
|
165 |
/** |
b6479e048c6e
(svn r10746) -Codechange: add a generic superclass for almost all pool items so we do not have to duplicate code for each of the pool item classes and use it for the station and roadstop classes.
rubidium
parents:
7376
diff
changeset
|
166 |
* The pool-wide index of this object. |
b6479e048c6e
(svn r10746) -Codechange: add a generic superclass for almost all pool items so we do not have to duplicate code for each of the pool item classes and use it for the station and roadstop classes.
rubidium
parents:
7376
diff
changeset
|
167 |
*/ |
b6479e048c6e
(svn r10746) -Codechange: add a generic superclass for almost all pool items so we do not have to duplicate code for each of the pool item classes and use it for the station and roadstop classes.
rubidium
parents:
7376
diff
changeset
|
168 |
Tid index; |
b6479e048c6e
(svn r10746) -Codechange: add a generic superclass for almost all pool items so we do not have to duplicate code for each of the pool item classes and use it for the station and roadstop classes.
rubidium
parents:
7376
diff
changeset
|
169 |
|
b6479e048c6e
(svn r10746) -Codechange: add a generic superclass for almost all pool items so we do not have to duplicate code for each of the pool item classes and use it for the station and roadstop classes.
rubidium
parents:
7376
diff
changeset
|
170 |
/** |
b6479e048c6e
(svn r10746) -Codechange: add a generic superclass for almost all pool items so we do not have to duplicate code for each of the pool item classes and use it for the station and roadstop classes.
rubidium
parents:
7376
diff
changeset
|
171 |
* We like to have the correct class destructed. |
7974
dfe3185a62d2
(svn r11530) -Codechange: do not update Tpool->first_free_index for PoolItems allocated on stack
smatz
parents:
7496
diff
changeset
|
172 |
* @warning It is called even for object allocated on stack, |
dfe3185a62d2
(svn r11530) -Codechange: do not update Tpool->first_free_index for PoolItems allocated on stack
smatz
parents:
7496
diff
changeset
|
173 |
* so it is not present in the TPool! |
dfe3185a62d2
(svn r11530) -Codechange: do not update Tpool->first_free_index for PoolItems allocated on stack
smatz
parents:
7496
diff
changeset
|
174 |
* Then, index is undefined, not associated with TPool in any way. |
dfe3185a62d2
(svn r11530) -Codechange: do not update Tpool->first_free_index for PoolItems allocated on stack
smatz
parents:
7496
diff
changeset
|
175 |
* @note The idea is to free up allocated memory etc. |
7377
b6479e048c6e
(svn r10746) -Codechange: add a generic superclass for almost all pool items so we do not have to duplicate code for each of the pool item classes and use it for the station and roadstop classes.
rubidium
parents:
7376
diff
changeset
|
176 |
*/ |
b6479e048c6e
(svn r10746) -Codechange: add a generic superclass for almost all pool items so we do not have to duplicate code for each of the pool item classes and use it for the station and roadstop classes.
rubidium
parents:
7376
diff
changeset
|
177 |
virtual ~PoolItem() |
b6479e048c6e
(svn r10746) -Codechange: add a generic superclass for almost all pool items so we do not have to duplicate code for each of the pool item classes and use it for the station and roadstop classes.
rubidium
parents:
7376
diff
changeset
|
178 |
{ |
7974
dfe3185a62d2
(svn r11530) -Codechange: do not update Tpool->first_free_index for PoolItems allocated on stack
smatz
parents:
7496
diff
changeset
|
179 |
|
dfe3185a62d2
(svn r11530) -Codechange: do not update Tpool->first_free_index for PoolItems allocated on stack
smatz
parents:
7496
diff
changeset
|
180 |
} |
dfe3185a62d2
(svn r11530) -Codechange: do not update Tpool->first_free_index for PoolItems allocated on stack
smatz
parents:
7496
diff
changeset
|
181 |
|
dfe3185a62d2
(svn r11530) -Codechange: do not update Tpool->first_free_index for PoolItems allocated on stack
smatz
parents:
7496
diff
changeset
|
182 |
/** |
dfe3185a62d2
(svn r11530) -Codechange: do not update Tpool->first_free_index for PoolItems allocated on stack
smatz
parents:
7496
diff
changeset
|
183 |
* Constructor of given class. |
dfe3185a62d2
(svn r11530) -Codechange: do not update Tpool->first_free_index for PoolItems allocated on stack
smatz
parents:
7496
diff
changeset
|
184 |
* @warning It is called even for object allocated on stack, |
dfe3185a62d2
(svn r11530) -Codechange: do not update Tpool->first_free_index for PoolItems allocated on stack
smatz
parents:
7496
diff
changeset
|
185 |
* so it may not be present in TPool! |
dfe3185a62d2
(svn r11530) -Codechange: do not update Tpool->first_free_index for PoolItems allocated on stack
smatz
parents:
7496
diff
changeset
|
186 |
* Then, index is undefined, not associated with TPool in any way. |
dfe3185a62d2
(svn r11530) -Codechange: do not update Tpool->first_free_index for PoolItems allocated on stack
smatz
parents:
7496
diff
changeset
|
187 |
* @note The idea is to initialize variables (except index) |
dfe3185a62d2
(svn r11530) -Codechange: do not update Tpool->first_free_index for PoolItems allocated on stack
smatz
parents:
7496
diff
changeset
|
188 |
*/ |
dfe3185a62d2
(svn r11530) -Codechange: do not update Tpool->first_free_index for PoolItems allocated on stack
smatz
parents:
7496
diff
changeset
|
189 |
PoolItem() |
dfe3185a62d2
(svn r11530) -Codechange: do not update Tpool->first_free_index for PoolItems allocated on stack
smatz
parents:
7496
diff
changeset
|
190 |
{ |
dfe3185a62d2
(svn r11530) -Codechange: do not update Tpool->first_free_index for PoolItems allocated on stack
smatz
parents:
7496
diff
changeset
|
191 |
|
7377
b6479e048c6e
(svn r10746) -Codechange: add a generic superclass for almost all pool items so we do not have to duplicate code for each of the pool item classes and use it for the station and roadstop classes.
rubidium
parents:
7376
diff
changeset
|
192 |
} |
b6479e048c6e
(svn r10746) -Codechange: add a generic superclass for almost all pool items so we do not have to duplicate code for each of the pool item classes and use it for the station and roadstop classes.
rubidium
parents:
7376
diff
changeset
|
193 |
|
b6479e048c6e
(svn r10746) -Codechange: add a generic superclass for almost all pool items so we do not have to duplicate code for each of the pool item classes and use it for the station and roadstop classes.
rubidium
parents:
7376
diff
changeset
|
194 |
/** |
b6479e048c6e
(svn r10746) -Codechange: add a generic superclass for almost all pool items so we do not have to duplicate code for each of the pool item classes and use it for the station and roadstop classes.
rubidium
parents:
7376
diff
changeset
|
195 |
* An overriden version of new that allocates memory on the pool. |
b6479e048c6e
(svn r10746) -Codechange: add a generic superclass for almost all pool items so we do not have to duplicate code for each of the pool item classes and use it for the station and roadstop classes.
rubidium
parents:
7376
diff
changeset
|
196 |
* @param size the size of the variable (unused) |
b6479e048c6e
(svn r10746) -Codechange: add a generic superclass for almost all pool items so we do not have to duplicate code for each of the pool item classes and use it for the station and roadstop classes.
rubidium
parents:
7376
diff
changeset
|
197 |
* @return the memory that is 'allocated' |
b6479e048c6e
(svn r10746) -Codechange: add a generic superclass for almost all pool items so we do not have to duplicate code for each of the pool item classes and use it for the station and roadstop classes.
rubidium
parents:
7376
diff
changeset
|
198 |
*/ |
7381
d7991ec3f19d
(svn r10750) -Codechange: make the waypoint struct use the new poolitem class as super class.
rubidium
parents:
7378
diff
changeset
|
199 |
void *operator new(size_t size) |
7377
b6479e048c6e
(svn r10746) -Codechange: add a generic superclass for almost all pool items so we do not have to duplicate code for each of the pool item classes and use it for the station and roadstop classes.
rubidium
parents:
7376
diff
changeset
|
200 |
{ |
b6479e048c6e
(svn r10746) -Codechange: add a generic superclass for almost all pool items so we do not have to duplicate code for each of the pool item classes and use it for the station and roadstop classes.
rubidium
parents:
7376
diff
changeset
|
201 |
return AllocateRaw(); |
b6479e048c6e
(svn r10746) -Codechange: add a generic superclass for almost all pool items so we do not have to duplicate code for each of the pool item classes and use it for the station and roadstop classes.
rubidium
parents:
7376
diff
changeset
|
202 |
} |
b6479e048c6e
(svn r10746) -Codechange: add a generic superclass for almost all pool items so we do not have to duplicate code for each of the pool item classes and use it for the station and roadstop classes.
rubidium
parents:
7376
diff
changeset
|
203 |
|
b6479e048c6e
(svn r10746) -Codechange: add a generic superclass for almost all pool items so we do not have to duplicate code for each of the pool item classes and use it for the station and roadstop classes.
rubidium
parents:
7376
diff
changeset
|
204 |
/** |
b6479e048c6e
(svn r10746) -Codechange: add a generic superclass for almost all pool items so we do not have to duplicate code for each of the pool item classes and use it for the station and roadstop classes.
rubidium
parents:
7376
diff
changeset
|
205 |
* 'Free' the memory allocated by the overriden new. |
b6479e048c6e
(svn r10746) -Codechange: add a generic superclass for almost all pool items so we do not have to duplicate code for each of the pool item classes and use it for the station and roadstop classes.
rubidium
parents:
7376
diff
changeset
|
206 |
* @param p the memory to 'free' |
7974
dfe3185a62d2
(svn r11530) -Codechange: do not update Tpool->first_free_index for PoolItems allocated on stack
smatz
parents:
7496
diff
changeset
|
207 |
* @note we only update Tpool->first_free_index |
7377
b6479e048c6e
(svn r10746) -Codechange: add a generic superclass for almost all pool items so we do not have to duplicate code for each of the pool item classes and use it for the station and roadstop classes.
rubidium
parents:
7376
diff
changeset
|
208 |
*/ |
b6479e048c6e
(svn r10746) -Codechange: add a generic superclass for almost all pool items so we do not have to duplicate code for each of the pool item classes and use it for the station and roadstop classes.
rubidium
parents:
7376
diff
changeset
|
209 |
void operator delete(void *p) |
b6479e048c6e
(svn r10746) -Codechange: add a generic superclass for almost all pool items so we do not have to duplicate code for each of the pool item classes and use it for the station and roadstop classes.
rubidium
parents:
7376
diff
changeset
|
210 |
{ |
7974
dfe3185a62d2
(svn r11530) -Codechange: do not update Tpool->first_free_index for PoolItems allocated on stack
smatz
parents:
7496
diff
changeset
|
211 |
Tpool->UpdateFirstFreeIndex(((T*)p)->index); |
7377
b6479e048c6e
(svn r10746) -Codechange: add a generic superclass for almost all pool items so we do not have to duplicate code for each of the pool item classes and use it for the station and roadstop classes.
rubidium
parents:
7376
diff
changeset
|
212 |
} |
b6479e048c6e
(svn r10746) -Codechange: add a generic superclass for almost all pool items so we do not have to duplicate code for each of the pool item classes and use it for the station and roadstop classes.
rubidium
parents:
7376
diff
changeset
|
213 |
|
b6479e048c6e
(svn r10746) -Codechange: add a generic superclass for almost all pool items so we do not have to duplicate code for each of the pool item classes and use it for the station and roadstop classes.
rubidium
parents:
7376
diff
changeset
|
214 |
/** |
b6479e048c6e
(svn r10746) -Codechange: add a generic superclass for almost all pool items so we do not have to duplicate code for each of the pool item classes and use it for the station and roadstop classes.
rubidium
parents:
7376
diff
changeset
|
215 |
* An overriden version of new, so you can directly allocate a new object with |
b6479e048c6e
(svn r10746) -Codechange: add a generic superclass for almost all pool items so we do not have to duplicate code for each of the pool item classes and use it for the station and roadstop classes.
rubidium
parents:
7376
diff
changeset
|
216 |
* the correct index when one is loading the savegame. |
b6479e048c6e
(svn r10746) -Codechange: add a generic superclass for almost all pool items so we do not have to duplicate code for each of the pool item classes and use it for the station and roadstop classes.
rubidium
parents:
7376
diff
changeset
|
217 |
* @param size the size of the variable (unused) |
b6479e048c6e
(svn r10746) -Codechange: add a generic superclass for almost all pool items so we do not have to duplicate code for each of the pool item classes and use it for the station and roadstop classes.
rubidium
parents:
7376
diff
changeset
|
218 |
* @param index the index of the object |
b6479e048c6e
(svn r10746) -Codechange: add a generic superclass for almost all pool items so we do not have to duplicate code for each of the pool item classes and use it for the station and roadstop classes.
rubidium
parents:
7376
diff
changeset
|
219 |
* @return the memory that is 'allocated' |
b6479e048c6e
(svn r10746) -Codechange: add a generic superclass for almost all pool items so we do not have to duplicate code for each of the pool item classes and use it for the station and roadstop classes.
rubidium
parents:
7376
diff
changeset
|
220 |
*/ |
7381
d7991ec3f19d
(svn r10750) -Codechange: make the waypoint struct use the new poolitem class as super class.
rubidium
parents:
7378
diff
changeset
|
221 |
void *operator new(size_t size, int index) |
7377
b6479e048c6e
(svn r10746) -Codechange: add a generic superclass for almost all pool items so we do not have to duplicate code for each of the pool item classes and use it for the station and roadstop classes.
rubidium
parents:
7376
diff
changeset
|
222 |
{ |
b6479e048c6e
(svn r10746) -Codechange: add a generic superclass for almost all pool items so we do not have to duplicate code for each of the pool item classes and use it for the station and roadstop classes.
rubidium
parents:
7376
diff
changeset
|
223 |
if (!Tpool->AddBlockIfNeeded(index)) error("%s: failed loading savegame: too many %s", Tpool->GetName(), Tpool->GetName()); |
b6479e048c6e
(svn r10746) -Codechange: add a generic superclass for almost all pool items so we do not have to duplicate code for each of the pool item classes and use it for the station and roadstop classes.
rubidium
parents:
7376
diff
changeset
|
224 |
|
b6479e048c6e
(svn r10746) -Codechange: add a generic superclass for almost all pool items so we do not have to duplicate code for each of the pool item classes and use it for the station and roadstop classes.
rubidium
parents:
7376
diff
changeset
|
225 |
return Tpool->Get(index); |
b6479e048c6e
(svn r10746) -Codechange: add a generic superclass for almost all pool items so we do not have to duplicate code for each of the pool item classes and use it for the station and roadstop classes.
rubidium
parents:
7376
diff
changeset
|
226 |
} |
b6479e048c6e
(svn r10746) -Codechange: add a generic superclass for almost all pool items so we do not have to duplicate code for each of the pool item classes and use it for the station and roadstop classes.
rubidium
parents:
7376
diff
changeset
|
227 |
|
b6479e048c6e
(svn r10746) -Codechange: add a generic superclass for almost all pool items so we do not have to duplicate code for each of the pool item classes and use it for the station and roadstop classes.
rubidium
parents:
7376
diff
changeset
|
228 |
/** |
b6479e048c6e
(svn r10746) -Codechange: add a generic superclass for almost all pool items so we do not have to duplicate code for each of the pool item classes and use it for the station and roadstop classes.
rubidium
parents:
7376
diff
changeset
|
229 |
* 'Free' the memory allocated by the overriden new. |
b6479e048c6e
(svn r10746) -Codechange: add a generic superclass for almost all pool items so we do not have to duplicate code for each of the pool item classes and use it for the station and roadstop classes.
rubidium
parents:
7376
diff
changeset
|
230 |
* @param p the memory to 'free' |
b6479e048c6e
(svn r10746) -Codechange: add a generic superclass for almost all pool items so we do not have to duplicate code for each of the pool item classes and use it for the station and roadstop classes.
rubidium
parents:
7376
diff
changeset
|
231 |
* @param index the original parameter given to create the memory |
7974
dfe3185a62d2
(svn r11530) -Codechange: do not update Tpool->first_free_index for PoolItems allocated on stack
smatz
parents:
7496
diff
changeset
|
232 |
* @note we only update Tpool->first_free_index |
7377
b6479e048c6e
(svn r10746) -Codechange: add a generic superclass for almost all pool items so we do not have to duplicate code for each of the pool item classes and use it for the station and roadstop classes.
rubidium
parents:
7376
diff
changeset
|
233 |
*/ |
b6479e048c6e
(svn r10746) -Codechange: add a generic superclass for almost all pool items so we do not have to duplicate code for each of the pool item classes and use it for the station and roadstop classes.
rubidium
parents:
7376
diff
changeset
|
234 |
void operator delete(void *p, int index) |
b6479e048c6e
(svn r10746) -Codechange: add a generic superclass for almost all pool items so we do not have to duplicate code for each of the pool item classes and use it for the station and roadstop classes.
rubidium
parents:
7376
diff
changeset
|
235 |
{ |
7974
dfe3185a62d2
(svn r11530) -Codechange: do not update Tpool->first_free_index for PoolItems allocated on stack
smatz
parents:
7496
diff
changeset
|
236 |
Tpool->UpdateFirstFreeIndex(index); |
7377
b6479e048c6e
(svn r10746) -Codechange: add a generic superclass for almost all pool items so we do not have to duplicate code for each of the pool item classes and use it for the station and roadstop classes.
rubidium
parents:
7376
diff
changeset
|
237 |
} |
b6479e048c6e
(svn r10746) -Codechange: add a generic superclass for almost all pool items so we do not have to duplicate code for each of the pool item classes and use it for the station and roadstop classes.
rubidium
parents:
7376
diff
changeset
|
238 |
|
b6479e048c6e
(svn r10746) -Codechange: add a generic superclass for almost all pool items so we do not have to duplicate code for each of the pool item classes and use it for the station and roadstop classes.
rubidium
parents:
7376
diff
changeset
|
239 |
/** |
b6479e048c6e
(svn r10746) -Codechange: add a generic superclass for almost all pool items so we do not have to duplicate code for each of the pool item classes and use it for the station and roadstop classes.
rubidium
parents:
7376
diff
changeset
|
240 |
* An overriden version of new, so you can use the vehicle instance |
b6479e048c6e
(svn r10746) -Codechange: add a generic superclass for almost all pool items so we do not have to duplicate code for each of the pool item classes and use it for the station and roadstop classes.
rubidium
parents:
7376
diff
changeset
|
241 |
* instead of a newly allocated piece of memory. |
b6479e048c6e
(svn r10746) -Codechange: add a generic superclass for almost all pool items so we do not have to duplicate code for each of the pool item classes and use it for the station and roadstop classes.
rubidium
parents:
7376
diff
changeset
|
242 |
* @param size the size of the variable (unused) |
b6479e048c6e
(svn r10746) -Codechange: add a generic superclass for almost all pool items so we do not have to duplicate code for each of the pool item classes and use it for the station and roadstop classes.
rubidium
parents:
7376
diff
changeset
|
243 |
* @param pn the already existing object to use as 'storage' backend |
b6479e048c6e
(svn r10746) -Codechange: add a generic superclass for almost all pool items so we do not have to duplicate code for each of the pool item classes and use it for the station and roadstop classes.
rubidium
parents:
7376
diff
changeset
|
244 |
* @return the memory that is 'allocated' |
b6479e048c6e
(svn r10746) -Codechange: add a generic superclass for almost all pool items so we do not have to duplicate code for each of the pool item classes and use it for the station and roadstop classes.
rubidium
parents:
7376
diff
changeset
|
245 |
*/ |
b6479e048c6e
(svn r10746) -Codechange: add a generic superclass for almost all pool items so we do not have to duplicate code for each of the pool item classes and use it for the station and roadstop classes.
rubidium
parents:
7376
diff
changeset
|
246 |
void *operator new(size_t size, T *pn) |
b6479e048c6e
(svn r10746) -Codechange: add a generic superclass for almost all pool items so we do not have to duplicate code for each of the pool item classes and use it for the station and roadstop classes.
rubidium
parents:
7376
diff
changeset
|
247 |
{ |
b6479e048c6e
(svn r10746) -Codechange: add a generic superclass for almost all pool items so we do not have to duplicate code for each of the pool item classes and use it for the station and roadstop classes.
rubidium
parents:
7376
diff
changeset
|
248 |
return pn; |
b6479e048c6e
(svn r10746) -Codechange: add a generic superclass for almost all pool items so we do not have to duplicate code for each of the pool item classes and use it for the station and roadstop classes.
rubidium
parents:
7376
diff
changeset
|
249 |
} |
b6479e048c6e
(svn r10746) -Codechange: add a generic superclass for almost all pool items so we do not have to duplicate code for each of the pool item classes and use it for the station and roadstop classes.
rubidium
parents:
7376
diff
changeset
|
250 |
|
b6479e048c6e
(svn r10746) -Codechange: add a generic superclass for almost all pool items so we do not have to duplicate code for each of the pool item classes and use it for the station and roadstop classes.
rubidium
parents:
7376
diff
changeset
|
251 |
/** |
b6479e048c6e
(svn r10746) -Codechange: add a generic superclass for almost all pool items so we do not have to duplicate code for each of the pool item classes and use it for the station and roadstop classes.
rubidium
parents:
7376
diff
changeset
|
252 |
* 'Free' the memory allocated by the overriden new. |
b6479e048c6e
(svn r10746) -Codechange: add a generic superclass for almost all pool items so we do not have to duplicate code for each of the pool item classes and use it for the station and roadstop classes.
rubidium
parents:
7376
diff
changeset
|
253 |
* @param p the memory to 'free' |
b6479e048c6e
(svn r10746) -Codechange: add a generic superclass for almost all pool items so we do not have to duplicate code for each of the pool item classes and use it for the station and roadstop classes.
rubidium
parents:
7376
diff
changeset
|
254 |
* @param pn the pointer that was given to 'new' on creation. |
7974
dfe3185a62d2
(svn r11530) -Codechange: do not update Tpool->first_free_index for PoolItems allocated on stack
smatz
parents:
7496
diff
changeset
|
255 |
* @note we only update Tpool->first_free_index |
7377
b6479e048c6e
(svn r10746) -Codechange: add a generic superclass for almost all pool items so we do not have to duplicate code for each of the pool item classes and use it for the station and roadstop classes.
rubidium
parents:
7376
diff
changeset
|
256 |
*/ |
b6479e048c6e
(svn r10746) -Codechange: add a generic superclass for almost all pool items so we do not have to duplicate code for each of the pool item classes and use it for the station and roadstop classes.
rubidium
parents:
7376
diff
changeset
|
257 |
void operator delete(void *p, T *pn) |
b6479e048c6e
(svn r10746) -Codechange: add a generic superclass for almost all pool items so we do not have to duplicate code for each of the pool item classes and use it for the station and roadstop classes.
rubidium
parents:
7376
diff
changeset
|
258 |
{ |
7974
dfe3185a62d2
(svn r11530) -Codechange: do not update Tpool->first_free_index for PoolItems allocated on stack
smatz
parents:
7496
diff
changeset
|
259 |
Tpool->UpdateFirstFreeIndex(pn->index); |
7377
b6479e048c6e
(svn r10746) -Codechange: add a generic superclass for almost all pool items so we do not have to duplicate code for each of the pool item classes and use it for the station and roadstop classes.
rubidium
parents:
7376
diff
changeset
|
260 |
} |
b6479e048c6e
(svn r10746) -Codechange: add a generic superclass for almost all pool items so we do not have to duplicate code for each of the pool item classes and use it for the station and roadstop classes.
rubidium
parents:
7376
diff
changeset
|
261 |
|
7426
e8dd555767bd
(svn r10827) -Fix [FS#1112]: out of bounds access in corner case of list allocations of vehicles.
rubidium
parents:
7413
diff
changeset
|
262 |
private: |
8847
426dd2d582e7
(svn r12599) -Codechange: force AllocateSafeRaw() to be linked to simplify compiler's decisions about inlining
smatz
parents:
8113
diff
changeset
|
263 |
static T *AllocateSafeRaw(uint &first); |
7413
a590f7f0edb3
(svn r10799) -Fix: only calling QuickFree and not the destructor on pool cleanups might cause memory leaks due to the way C++ works.
rubidium
parents:
7402
diff
changeset
|
264 |
|
7426
e8dd555767bd
(svn r10827) -Fix [FS#1112]: out of bounds access in corner case of list allocations of vehicles.
rubidium
parents:
7413
diff
changeset
|
265 |
protected: |
e8dd555767bd
(svn r10827) -Fix [FS#1112]: out of bounds access in corner case of list allocations of vehicles.
rubidium
parents:
7413
diff
changeset
|
266 |
/** |
e8dd555767bd
(svn r10827) -Fix [FS#1112]: out of bounds access in corner case of list allocations of vehicles.
rubidium
parents:
7413
diff
changeset
|
267 |
* Allocate a pool item; possibly allocate a new block in the pool. |
e8dd555767bd
(svn r10827) -Fix [FS#1112]: out of bounds access in corner case of list allocations of vehicles.
rubidium
parents:
7413
diff
changeset
|
268 |
* @return the allocated pool item (or NULL when the pool is full). |
e8dd555767bd
(svn r10827) -Fix [FS#1112]: out of bounds access in corner case of list allocations of vehicles.
rubidium
parents:
7413
diff
changeset
|
269 |
*/ |
e8dd555767bd
(svn r10827) -Fix [FS#1112]: out of bounds access in corner case of list allocations of vehicles.
rubidium
parents:
7413
diff
changeset
|
270 |
static inline T *AllocateRaw() |
e8dd555767bd
(svn r10827) -Fix [FS#1112]: out of bounds access in corner case of list allocations of vehicles.
rubidium
parents:
7413
diff
changeset
|
271 |
{ |
e8dd555767bd
(svn r10827) -Fix [FS#1112]: out of bounds access in corner case of list allocations of vehicles.
rubidium
parents:
7413
diff
changeset
|
272 |
return AllocateSafeRaw(Tpool->first_free_index); |
e8dd555767bd
(svn r10827) -Fix [FS#1112]: out of bounds access in corner case of list allocations of vehicles.
rubidium
parents:
7413
diff
changeset
|
273 |
} |
e8dd555767bd
(svn r10827) -Fix [FS#1112]: out of bounds access in corner case of list allocations of vehicles.
rubidium
parents:
7413
diff
changeset
|
274 |
|
e8dd555767bd
(svn r10827) -Fix [FS#1112]: out of bounds access in corner case of list allocations of vehicles.
rubidium
parents:
7413
diff
changeset
|
275 |
/** |
e8dd555767bd
(svn r10827) -Fix [FS#1112]: out of bounds access in corner case of list allocations of vehicles.
rubidium
parents:
7413
diff
changeset
|
276 |
* Allocate a pool item; possibly allocate a new block in the pool. |
e8dd555767bd
(svn r10827) -Fix [FS#1112]: out of bounds access in corner case of list allocations of vehicles.
rubidium
parents:
7413
diff
changeset
|
277 |
* @param first the first pool item to start searching |
e8dd555767bd
(svn r10827) -Fix [FS#1112]: out of bounds access in corner case of list allocations of vehicles.
rubidium
parents:
7413
diff
changeset
|
278 |
* @return the allocated pool item (or NULL when the pool is full). |
e8dd555767bd
(svn r10827) -Fix [FS#1112]: out of bounds access in corner case of list allocations of vehicles.
rubidium
parents:
7413
diff
changeset
|
279 |
*/ |
e8dd555767bd
(svn r10827) -Fix [FS#1112]: out of bounds access in corner case of list allocations of vehicles.
rubidium
parents:
7413
diff
changeset
|
280 |
static inline T *AllocateRaw(uint &first) |
e8dd555767bd
(svn r10827) -Fix [FS#1112]: out of bounds access in corner case of list allocations of vehicles.
rubidium
parents:
7413
diff
changeset
|
281 |
{ |
e8dd555767bd
(svn r10827) -Fix [FS#1112]: out of bounds access in corner case of list allocations of vehicles.
rubidium
parents:
7413
diff
changeset
|
282 |
if (first >= Tpool->GetSize() && !Tpool->AddBlockToPool()) return NULL; |
e8dd555767bd
(svn r10827) -Fix [FS#1112]: out of bounds access in corner case of list allocations of vehicles.
rubidium
parents:
7413
diff
changeset
|
283 |
|
e8dd555767bd
(svn r10827) -Fix [FS#1112]: out of bounds access in corner case of list allocations of vehicles.
rubidium
parents:
7413
diff
changeset
|
284 |
return AllocateSafeRaw(first); |
e8dd555767bd
(svn r10827) -Fix [FS#1112]: out of bounds access in corner case of list allocations of vehicles.
rubidium
parents:
7413
diff
changeset
|
285 |
} |
e8dd555767bd
(svn r10827) -Fix [FS#1112]: out of bounds access in corner case of list allocations of vehicles.
rubidium
parents:
7413
diff
changeset
|
286 |
|
7413
a590f7f0edb3
(svn r10799) -Fix: only calling QuickFree and not the destructor on pool cleanups might cause memory leaks due to the way C++ works.
rubidium
parents:
7402
diff
changeset
|
287 |
/** |
a590f7f0edb3
(svn r10799) -Fix: only calling QuickFree and not the destructor on pool cleanups might cause memory leaks due to the way C++ works.
rubidium
parents:
7402
diff
changeset
|
288 |
* Are we cleaning this pool? |
a590f7f0edb3
(svn r10799) -Fix: only calling QuickFree and not the destructor on pool cleanups might cause memory leaks due to the way C++ works.
rubidium
parents:
7402
diff
changeset
|
289 |
* @return true if we are |
a590f7f0edb3
(svn r10799) -Fix: only calling QuickFree and not the destructor on pool cleanups might cause memory leaks due to the way C++ works.
rubidium
parents:
7402
diff
changeset
|
290 |
*/ |
a590f7f0edb3
(svn r10799) -Fix: only calling QuickFree and not the destructor on pool cleanups might cause memory leaks due to the way C++ works.
rubidium
parents:
7402
diff
changeset
|
291 |
static inline bool CleaningPool() |
a590f7f0edb3
(svn r10799) -Fix: only calling QuickFree and not the destructor on pool cleanups might cause memory leaks due to the way C++ works.
rubidium
parents:
7402
diff
changeset
|
292 |
{ |
a590f7f0edb3
(svn r10799) -Fix: only calling QuickFree and not the destructor on pool cleanups might cause memory leaks due to the way C++ works.
rubidium
parents:
7402
diff
changeset
|
293 |
return Tpool->CleaningPool(); |
a590f7f0edb3
(svn r10799) -Fix: only calling QuickFree and not the destructor on pool cleanups might cause memory leaks due to the way C++ works.
rubidium
parents:
7402
diff
changeset
|
294 |
} |
9036
6368fe55fd6d
(svn r12855) -Codechange: do not use autoptr's for testing whether certain objects can be build, but check it directly in the pool so we do not have to call destructors in the testing phase. Stations still use the autoptr though.
rubidium
parents:
8847
diff
changeset
|
295 |
|
6368fe55fd6d
(svn r12855) -Codechange: do not use autoptr's for testing whether certain objects can be build, but check it directly in the pool so we do not have to call destructors in the testing phase. Stations still use the autoptr though.
rubidium
parents:
8847
diff
changeset
|
296 |
public: |
9038
38f0f10f8cca
(svn r12857) -Fix [FS#1948]: remove the last uses of AutoPtr in the station code.
rubidium
parents:
9036
diff
changeset
|
297 |
static bool CanAllocateItem(); |
7377
b6479e048c6e
(svn r10746) -Codechange: add a generic superclass for almost all pool items so we do not have to duplicate code for each of the pool item classes and use it for the station and roadstop classes.
rubidium
parents:
7376
diff
changeset
|
298 |
}; |
b6479e048c6e
(svn r10746) -Codechange: add a generic superclass for almost all pool items so we do not have to duplicate code for each of the pool item classes and use it for the station and roadstop classes.
rubidium
parents:
7376
diff
changeset
|
299 |
|
7376
066596e64cd5
(svn r10745) -Codechange: generalize the pool cleanup/initialize functions for stations (in such a manner that they can be used for other pools too).
rubidium
parents:
7375
diff
changeset
|
300 |
|
5216
8bd14ee39af2
(svn r7331) - Codechange: Rename all memory pool macro's and types to "old pool", so the new pool implementation can be committed alongside it.
matthijs
parents:
4986
diff
changeset
|
301 |
#define OLD_POOL_ENUM(name, type, block_size_bits, max_blocks) \ |
4970
eb2c0fde4b02
(svn r6973) Add macros to easily create a pool with less code duplication and more opportunities for constant expression evaluation
tron
parents:
3585
diff
changeset
|
302 |
enum { \ |
eb2c0fde4b02
(svn r6973) Add macros to easily create a pool with less code duplication and more opportunities for constant expression evaluation
tron
parents:
3585
diff
changeset
|
303 |
name##_POOL_BLOCK_SIZE_BITS = block_size_bits, \ |
eb2c0fde4b02
(svn r6973) Add macros to easily create a pool with less code duplication and more opportunities for constant expression evaluation
tron
parents:
3585
diff
changeset
|
304 |
name##_POOL_MAX_BLOCKS = max_blocks \ |
eb2c0fde4b02
(svn r6973) Add macros to easily create a pool with less code duplication and more opportunities for constant expression evaluation
tron
parents:
3585
diff
changeset
|
305 |
}; |
eb2c0fde4b02
(svn r6973) Add macros to easily create a pool with less code duplication and more opportunities for constant expression evaluation
tron
parents:
3585
diff
changeset
|
306 |
|
eb2c0fde4b02
(svn r6973) Add macros to easily create a pool with less code duplication and more opportunities for constant expression evaluation
tron
parents:
3585
diff
changeset
|
307 |
|
5216
8bd14ee39af2
(svn r7331) - Codechange: Rename all memory pool macro's and types to "old pool", so the new pool implementation can be committed alongside it.
matthijs
parents:
4986
diff
changeset
|
308 |
#define OLD_POOL_ACCESSORS(name, type) \ |
7375
961ab798c4b6
(svn r10744) -Codechange: make the pool a little more OO, so it can be easier in other places.
rubidium
parents:
6351
diff
changeset
|
309 |
static inline type* Get##name(uint index) { return _##name##_pool.Get(index); } \ |
961ab798c4b6
(svn r10744) -Codechange: make the pool a little more OO, so it can be easier in other places.
rubidium
parents:
6351
diff
changeset
|
310 |
static inline uint Get##name##PoolSize() { return _##name##_pool.GetSize(); } |
4970
eb2c0fde4b02
(svn r6973) Add macros to easily create a pool with less code duplication and more opportunities for constant expression evaluation
tron
parents:
3585
diff
changeset
|
311 |
|
eb2c0fde4b02
(svn r6973) Add macros to easily create a pool with less code duplication and more opportunities for constant expression evaluation
tron
parents:
3585
diff
changeset
|
312 |
|
5216
8bd14ee39af2
(svn r7331) - Codechange: Rename all memory pool macro's and types to "old pool", so the new pool implementation can be committed alongside it.
matthijs
parents:
4986
diff
changeset
|
313 |
#define DECLARE_OLD_POOL(name, type, block_size_bits, max_blocks) \ |
8bd14ee39af2
(svn r7331) - Codechange: Rename all memory pool macro's and types to "old pool", so the new pool implementation can be committed alongside it.
matthijs
parents:
4986
diff
changeset
|
314 |
OLD_POOL_ENUM(name, type, block_size_bits, max_blocks) \ |
7375
961ab798c4b6
(svn r10744) -Codechange: make the pool a little more OO, so it can be easier in other places.
rubidium
parents:
6351
diff
changeset
|
315 |
extern OldMemoryPool<type> _##name##_pool; \ |
5216
8bd14ee39af2
(svn r7331) - Codechange: Rename all memory pool macro's and types to "old pool", so the new pool implementation can be committed alongside it.
matthijs
parents:
4986
diff
changeset
|
316 |
OLD_POOL_ACCESSORS(name, type) |
4970
eb2c0fde4b02
(svn r6973) Add macros to easily create a pool with less code duplication and more opportunities for constant expression evaluation
tron
parents:
3585
diff
changeset
|
317 |
|
eb2c0fde4b02
(svn r6973) Add macros to easily create a pool with less code duplication and more opportunities for constant expression evaluation
tron
parents:
3585
diff
changeset
|
318 |
|
5216
8bd14ee39af2
(svn r7331) - Codechange: Rename all memory pool macro's and types to "old pool", so the new pool implementation can be committed alongside it.
matthijs
parents:
4986
diff
changeset
|
319 |
#define DEFINE_OLD_POOL(name, type, new_block_proc, clean_block_proc) \ |
7375
961ab798c4b6
(svn r10744) -Codechange: make the pool a little more OO, so it can be easier in other places.
rubidium
parents:
6351
diff
changeset
|
320 |
OldMemoryPool<type> _##name##_pool( \ |
4970
eb2c0fde4b02
(svn r6973) Add macros to easily create a pool with less code duplication and more opportunities for constant expression evaluation
tron
parents:
3585
diff
changeset
|
321 |
#name, name##_POOL_MAX_BLOCKS, name##_POOL_BLOCK_SIZE_BITS, sizeof(type), \ |
7375
961ab798c4b6
(svn r10744) -Codechange: make the pool a little more OO, so it can be easier in other places.
rubidium
parents:
6351
diff
changeset
|
322 |
new_block_proc, clean_block_proc); |
4970
eb2c0fde4b02
(svn r6973) Add macros to easily create a pool with less code duplication and more opportunities for constant expression evaluation
tron
parents:
3585
diff
changeset
|
323 |
|
7376
066596e64cd5
(svn r10745) -Codechange: generalize the pool cleanup/initialize functions for stations (in such a manner that they can be used for other pools too).
rubidium
parents:
7375
diff
changeset
|
324 |
#define DEFINE_OLD_POOL_GENERIC(name, type) \ |
066596e64cd5
(svn r10745) -Codechange: generalize the pool cleanup/initialize functions for stations (in such a manner that they can be used for other pools too).
rubidium
parents:
7375
diff
changeset
|
325 |
OldMemoryPool<type> _##name##_pool( \ |
066596e64cd5
(svn r10745) -Codechange: generalize the pool cleanup/initialize functions for stations (in such a manner that they can be used for other pools too).
rubidium
parents:
7375
diff
changeset
|
326 |
#name, name##_POOL_MAX_BLOCKS, name##_POOL_BLOCK_SIZE_BITS, sizeof(type), \ |
8847
426dd2d582e7
(svn r12599) -Codechange: force AllocateSafeRaw() to be linked to simplify compiler's decisions about inlining
smatz
parents:
8113
diff
changeset
|
327 |
PoolNewBlock<type, &_##name##_pool>, PoolCleanBlock<type, &_##name##_pool>); \ |
426dd2d582e7
(svn r12599) -Codechange: force AllocateSafeRaw() to be linked to simplify compiler's decisions about inlining
smatz
parents:
8113
diff
changeset
|
328 |
template type *PoolItem<type, type##ID, &_##name##_pool>::AllocateSafeRaw(uint &first); |
7376
066596e64cd5
(svn r10745) -Codechange: generalize the pool cleanup/initialize functions for stations (in such a manner that they can be used for other pools too).
rubidium
parents:
7375
diff
changeset
|
329 |
|
4970
eb2c0fde4b02
(svn r6973) Add macros to easily create a pool with less code duplication and more opportunities for constant expression evaluation
tron
parents:
3585
diff
changeset
|
330 |
|
5216
8bd14ee39af2
(svn r7331) - Codechange: Rename all memory pool macro's and types to "old pool", so the new pool implementation can be committed alongside it.
matthijs
parents:
4986
diff
changeset
|
331 |
#define STATIC_OLD_POOL(name, type, block_size_bits, max_blocks, new_block_proc, clean_block_proc) \ |
8bd14ee39af2
(svn r7331) - Codechange: Rename all memory pool macro's and types to "old pool", so the new pool implementation can be committed alongside it.
matthijs
parents:
4986
diff
changeset
|
332 |
OLD_POOL_ENUM(name, type, block_size_bits, max_blocks) \ |
8bd14ee39af2
(svn r7331) - Codechange: Rename all memory pool macro's and types to "old pool", so the new pool implementation can be committed alongside it.
matthijs
parents:
4986
diff
changeset
|
333 |
static DEFINE_OLD_POOL(name, type, new_block_proc, clean_block_proc) \ |
8bd14ee39af2
(svn r7331) - Codechange: Rename all memory pool macro's and types to "old pool", so the new pool implementation can be committed alongside it.
matthijs
parents:
4986
diff
changeset
|
334 |
OLD_POOL_ACCESSORS(name, type) |
4970
eb2c0fde4b02
(svn r6973) Add macros to easily create a pool with less code duplication and more opportunities for constant expression evaluation
tron
parents:
3585
diff
changeset
|
335 |
|
5224
df36f84cbb6c
(svn r7341) - Codechange: Also rename the POOL_H define to OLDPOOL_H (forgotten in r7331).
matthijs
parents:
5216
diff
changeset
|
336 |
#endif /* OLDPOOL_H */ |