1#ifndef INCLUDE_FB_BLK
2#define INCLUDE_FB_BLK
3
4#include "../common/classes/alloc.h"
5
6enum BlockType
7{
8 type_unknown = 0,
9
10 type_vec,
11 type_dbb,
12 type_bcb,
13 type_bdb,
14 type_pre,
15 type_lck,
16 type_fil,
17 type_pgc,
18 type_rel,
19 type_fmt,
20 type_vcl,
21 type_req,
22 type_tra,
23 type_nod,
24 type_csb,
25 type_rec,
26 type_rsb,
27 type_dfw,
28 type_tfb,
29 type_str,
30 type_blb,
31 type_irb,
32 type_fld,
33 type_ext,
34 type_att,
35 type_sym,
36 type_irl,
37 type_idl,
38 type_sdw,
39 type_vct,
40 type_blf,
41 type_arr,
42 type_map,
43 type_prm,
44 type_sav,
45 type_idb,
46 type_tpc,
47 type_svc,
48 type_lwt,
49 type_srpb,
50 type_opt,
51 type_prf,
52 type_ctl,
53 type_Events,
54 type_user_data,
55
56 type_PageSpace,
57 type_PageManager,
58
59 dsql_type_ctx,
60 dsql_type_map,
61 dsql_type_req,
62 dsql_type_dbb,
63 dsql_type_rel,
64 dsql_type_fld,
65 dsql_type_fil,
66 dsql_type_nod,
67 dsql_type_str,
68 dsql_type_tra,
69 dsql_type_udf,
70 dsql_type_prc,
71 dsql_type_intlsym,
72 dsql_type_imp_join,
73
74 alice_type_tdr,
75 alice_type_str,
76
77 rem_type_rdb,
78 rem_type_rrq,
79 rem_type_rtr,
80 rem_type_rbl,
81 rem_type_rsr,
82 rem_type_rev
83};
84
85
86template<BlockType BLOCK_TYPE>
87class TypedHandle
88{
89public:
90 TypedHandle() : blockType(BLOCK_TYPE) {}
91
92 TypedHandle<BLOCK_TYPE>& operator= (const TypedHandle<BLOCK_TYPE>& from)
93 {
94 blockType = from.blockType;
95 return *this;
96 }
97
98 BlockType getType() const
99 {
100 return blockType;
101 }
102
103 bool checkHandle() const
104 {
105 if (!this)
106 {
107 return false;
108 }
109
110 return (blockType == BLOCK_TYPE);
111 }
112
113private:
114 BlockType blockType;
115};
116
117template<BlockType BLOCK_TYPE = type_unknown>
118class pool_alloc : public TypedHandle<BLOCK_TYPE>
119{
120public:
121#ifdef DEBUG_GDS_ALLOC
122 void* operator new(size_t s, MemoryPool& p, const char* file, int line)
123 { return p.calloc(s, file, line); }
124 void* operator new[](size_t s, MemoryPool& p, const char* file, int line)
125 { return p.calloc(s, file, line); }
126#else
127 void* operator new(size_t s, MemoryPool& p )
128 { return p.calloc(s); }
129 void* operator new[](size_t s, MemoryPool& p)
130 { return p.calloc(s); }
131#endif
132
133 void operator delete(void* mem, MemoryPool& /*p*/)
134 {
135 if (mem)
136 MemoryPool::deallocate(mem);
137 }
138
139 void operator delete[](void* mem, MemoryPool& /*p*/)
140 {
141 if (mem)
142 MemoryPool::deallocate(mem);
143 }
144
145 void operator delete(void* mem)
146 {
147 if (mem)
148 MemoryPool::globalFree(mem);
149 }
150
151 void operator delete[](void* mem)
152 {
153 if (mem)
154 MemoryPool::globalFree(mem);
155 }
156
157private:
158 // These operators are off-limits
159 void* operator new(size_t) { return 0; }
160 void* operator new[](size_t) { return 0; }
161};
162
163template<typename RPT, BlockType BLOCK_TYPE = type_unknown>
164class pool_alloc_rpt : public TypedHandle<BLOCK_TYPE>
165{
166public:
167 typedef RPT blk_repeat_type;
168#ifdef DEBUG_GDS_ALLOC
169 void* operator new(size_t s, MemoryPool& p, size_t rpt, const char* file, int line)
170 { return p.calloc(s + sizeof(RPT) * rpt, file, line); }
171#else
172 void* operator new(size_t s, MemoryPool& p, size_t rpt)
173 { return p.calloc(s + sizeof(RPT) * rpt); }
174#endif
175 void operator delete(void* mem, MemoryPool& p)
176 {
177 if (mem)
178 p.deallocate(mem);
179 }
180
181 void operator delete(void* mem)
182 {
183 if (mem)
184 MemoryPool::globalFree(mem);
185 }
186
187private:
188 // These operations are not supported on static repeat-base objects
189 void* operator new[](size_t /*s*/, MemoryPool& /*p*/)
190 {
191 return 0;
192 }
193
194 void operator delete[](void* /*mem*/, MemoryPool& /*p*/)
195 {
196 }
197
198 void operator delete[](void* /*mem*/)
199 {
200 }
201
202 // These operators are off-limits
203 void* operator new(size_t) { return 0; }
204 void* operator new[](size_t) { return 0; }
205};
206
207#endif // INCLUDE_FB_BLK
208