ZFFramework
 
Loading...
Searching...
No Matches
ZFObjectRetain.h
Go to the documentation of this file.
1
5
6#ifndef _ZFI_ZFObjectRetain_h_
7#define _ZFI_ZFObjectRetain_h_
8
9#include "ZFObjectCore.h"
11
12// ============================================================
13// zfAlloc
14/* ZFMETHOD_MAX_PARAM */
15template<typename T_ZFObject, int valid>
16zfclassNotPOD _ZFP_Obj_AllocCk;
17template<typename T_ZFObject>
18zfclassNotPOD _ZFP_Obj_AllocCk<T_ZFObject, 1> {
19public:
20 static inline T_ZFObject *Alloc(void) {
21 ZFObject *obj = T_ZFObject::_ZFP_Obj_ctor();
22 obj->_ZFP_ZFObject_objectOnInit();
23 obj->_ZFP_ZFObject_objectOnInitFinish();
24 return _ZFP_ObjCastInternal(T_ZFObject *, obj);
25 }
26public:
27 static inline T_ZFObject *CanAlloc(void);
28 template<typename P0>
29 static inline T_ZFObject *CanAlloc(P0 const &p0) {
30 T_ZFObject *obj = _ZFP_ObjCastInternal(T_ZFObject *, T_ZFObject::_ZFP_Obj_ctor());
31 obj->_ZFP_ZFObject_objectOnInit();
32 obj->objectOnInit(p0);
33 obj->_ZFP_ZFObject_objectOnInitFinish();
34 return obj;
35 }
36 template<typename P0, typename P1>
37 static inline T_ZFObject *CanAlloc(P0 const &p0, P1 const &p1) {
38 T_ZFObject *obj = _ZFP_ObjCastInternal(T_ZFObject *, T_ZFObject::_ZFP_Obj_ctor());
39 obj->_ZFP_ZFObject_objectOnInit();
40 obj->objectOnInit(p0, p1);
41 obj->_ZFP_ZFObject_objectOnInitFinish();
42 return obj;
43 }
44 template<typename P0, typename P1, typename P2>
45 static inline T_ZFObject *CanAlloc(P0 const &p0, P1 const &p1, P2 const &p2) {
46 T_ZFObject *obj = _ZFP_ObjCastInternal(T_ZFObject *, T_ZFObject::_ZFP_Obj_ctor());
47 obj->_ZFP_ZFObject_objectOnInit();
48 obj->objectOnInit(p0, p1, p2);
49 obj->_ZFP_ZFObject_objectOnInitFinish();
50 return obj;
51 }
52 template<typename P0, typename P1, typename P2, typename P3>
53 static inline T_ZFObject *CanAlloc(P0 const &p0, P1 const &p1, P2 const &p2, P3 const &p3) {
54 T_ZFObject *obj = _ZFP_ObjCastInternal(T_ZFObject *, T_ZFObject::_ZFP_Obj_ctor());
55 obj->_ZFP_ZFObject_objectOnInit();
56 obj->objectOnInit(p0, p1, p2, p3);
57 obj->_ZFP_ZFObject_objectOnInitFinish();
58 return obj;
59 }
60 template<typename P0, typename P1, typename P2, typename P3, typename P4>
61 static inline T_ZFObject *CanAlloc(P0 const &p0, P1 const &p1, P2 const &p2, P3 const &p3, P4 const &p4) {
62 T_ZFObject *obj = _ZFP_ObjCastInternal(T_ZFObject *, T_ZFObject::_ZFP_Obj_ctor());
63 obj->_ZFP_ZFObject_objectOnInit();
64 obj->objectOnInit(p0, p1, p2, p3, p4);
65 obj->_ZFP_ZFObject_objectOnInitFinish();
66 return obj;
67 }
68 template<typename P0, typename P1, typename P2, typename P3, typename P4, typename P5>
69 static inline T_ZFObject *CanAlloc(P0 const &p0, P1 const &p1, P2 const &p2, P3 const &p3, P4 const &p4, P5 const &p5) {
70 T_ZFObject *obj = _ZFP_ObjCastInternal(T_ZFObject *, T_ZFObject::_ZFP_Obj_ctor());
71 obj->_ZFP_ZFObject_objectOnInit();
72 obj->objectOnInit(p0, p1, p2, p3, p4, p5);
73 obj->_ZFP_ZFObject_objectOnInitFinish();
74 return obj;
75 }
76 template<typename P0, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6>
77 static inline T_ZFObject *CanAlloc(P0 const &p0, P1 const &p1, P2 const &p2, P3 const &p3, P4 const &p4, P5 const &p5, P6 const &p6) {
78 T_ZFObject *obj = _ZFP_ObjCastInternal(T_ZFObject *, T_ZFObject::_ZFP_Obj_ctor());
79 obj->_ZFP_ZFObject_objectOnInit();
80 obj->objectOnInit(p0, p1, p2, p3, p4, p5, p6);
81 obj->_ZFP_ZFObject_objectOnInitFinish();
82 return obj;
83 }
84 template<typename P0, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7>
85 static inline T_ZFObject *CanAlloc(P0 const &p0, P1 const &p1, P2 const &p2, P3 const &p3, P4 const &p4, P5 const &p5, P6 const &p6, P7 const &p7) {
86 T_ZFObject *obj = _ZFP_ObjCastInternal(T_ZFObject *, T_ZFObject::_ZFP_Obj_ctor());
87 obj->_ZFP_ZFObject_objectOnInit();
88 obj->objectOnInit(p0, p1, p2, p3, p4, p5, p6, p7);
89 obj->_ZFP_ZFObject_objectOnInitFinish();
90 return obj;
91 }
92};
93template<typename T_ZFObject>
94zfclassNotPOD _ZFP_Obj_AllocCk<T_ZFObject, 0> {
95};
96#define _ZFP_zfAlloc(T_ZFObject, ...) \
97 _ZFP_Obj_AllocCk<T_ZFObject, T_ZFObject::_ZFP_ZFObjectCanAlloc && T_ZFObject::_ZFP_ZFObjectCanAllocPublic>::CanAlloc(__VA_ARGS__)
104#define zfAlloc(T_ZFObject, ...) \
105 zfunsafe_zfAlloc(T_ZFObject, ##__VA_ARGS__)
106
107#define zfunsafe_zfAlloc(T_ZFObject, ...) \
108 _ZFP_zfAlloc(T_ZFObject, ##__VA_ARGS__)
109
110#define _ZFP_zfAllocInternal(T_ZFObject) \
111 _ZFP_Obj_AllocCk<T_ZFObject, T_ZFObject::_ZFP_ZFObjectCanAlloc && T_ZFObject::_ZFP_ZFObjectCanAllocPublic>::Alloc()
112
113// ============================================================
114// zfRetain
115inline void _ZFP_zfRetainAction(ZF_IN ZFObject *obj) {
116 if(obj) {
117 obj->objectOnRetain();
118 }
119}
120template<typename T_ZFObject>
121inline T_ZFObject const &_ZFP_zfRetain(ZF_IN T_ZFObject const &obj) {
122 _ZFP_zfRetainAction(zfcast(ZFObject *, obj));
123 return obj;
124}
128#define zfRetain(obj) \
129 (ZFCoreMutexLockerHolder(), zfunsafe_zfRetain(obj))
130
131#define zfunsafe_zfRetain(obj) \
132 _ZFP_zfRetain(obj)
133
134// ============================================================
135// zfRelease
136inline void _ZFP_zfReleaseAction(ZF_IN ZFObject *obj) {
137 if(obj) {
138 obj->_ZFP_ZFObjectCheckRelease();
139 }
140}
141template<typename T_ZFObject>
142inline void _ZFP_zfRelease(ZF_IN T_ZFObject const &obj) {
143 _ZFP_zfReleaseAction(zfcast(ZFObject *, obj));
144}
148#define zfRelease(obj) \
149 (ZFCoreMutexLockerHolder(), zfunsafe_zfRelease(obj))
150
151#define zfunsafe_zfRelease(obj) \
152 _ZFP_zfRelease(obj)
153
154// ============================================================
155// ZFALLOC_CACHE_RELEASE
186#define ZFALLOC_CACHE_RELEASE(action) \
187 public: \
188 \
189 static ZFObject *_ZFP_zfAllocCacheIvk(void) { \
190 return _ZFP_zfAllocCache<zfself>::Alloc(); \
191 } \
192 static void _ZFP_zfAllocCacheRelease(ZF_IN ZFObject *_obj) { \
193 zfsuper::_ZFP_zfAllocCacheRelease(_obj); \
194 zfself *cache = zfcast(zfself *, _obj); \
195 ZFUNUSED(cache); \
196 action \
197 } \
198
199
201#define ZFALLOC_CACHE_RELEASE_ABSTRACT(action) \
202 public: \
203 \
204 static void _ZFP_zfAllocCacheRelease(ZF_IN ZFObject *_obj) { \
205 zfsuper::_ZFP_zfAllocCacheRelease(_obj); \
206 zfself *cache = zfcast(zfself *, _obj); \
207 ZFUNUSED(cache); \
208 action \
209 } \
210
211
216
217extern ZFLIB_ZFCore void _ZFP_zfAllocCacheImplRegister(
218 ZF_IN_OUT zfbool &enableFlag
219 , ZF_IN_OUT ZFObject **cache
220 , ZF_IN_OUT zfindex &cacheCount
221 );
222extern ZFLIB_ZFCore void _ZFP_zfAllocCacheImplUnregister(ZF_IN_OUT zfbool &enableFlag);
223template<typename T_ZFObject, int T_MaxCache = 16>
224zfclassNotPOD _ZFP_zfAllocCache {
225private:
226 typedef _ZFP_zfAllocCache<T_ZFObject, T_MaxCache> zfself;
227public:
228 static T_ZFObject *Alloc(void) {
229 static RegHolder _dummy;
230 ZFUNUSED(_dummy);
231 if(enableFlag()) {
232 if(cacheCount() > 0) {
233 ZFObject *ret = cache()[--(cacheCount())];
234 ret->_ZFP_ZFObject_zfAllocCacheRelease(zfself::_ZFP_zfAllocCacheRelease);
235 ret->_ZFP_ZFObject_objectOnInitFromCache();
236 return zfcast(T_ZFObject *, ret);
237 }
238 else {
239 T_ZFObject *ret = _ZFP_zfAllocInternal(T_ZFObject);
240 ret->_ZFP_ZFObject_zfAllocCacheRelease(zfself::_ZFP_zfAllocCacheRelease);
241 return ret;
242 }
243 }
244 else {
245 return _ZFP_zfAllocInternal(T_ZFObject);
246 }
247 }
248 static void _ZFP_zfAllocCacheRelease(ZF_IN ZFObject *obj) {
249 obj->_ZFP_ZFObject_zfAllocCacheRelease(zfnull);
250 if(enableFlag() && cacheCount() < T_MaxCache) {
251 T_ZFObject::_ZFP_zfAllocCacheRelease(obj);
252 cache()[cacheCount()++] = obj;
253 }
254 else {
256 }
257 }
258 static zfbool &enableFlag(void) {
259 static zfbool enableFlag = zffalse;
260 return enableFlag;
261 }
262 static ZFObject **cache(void) {
263 static ZFObject *cache[T_MaxCache];
264 return cache;
265 }
266 static zfindex &cacheCount(void) {
267 static zfindex cacheCount = 0;
268 return cacheCount;
269 }
270private:
271 zfclassNotPOD RegHolder {
272 public:
273 RegHolder(void) {
274 _ZFP_zfAllocCacheImplRegister(enableFlag(), cache(), cacheCount());
275 }
276 ~RegHolder(void) {
277 _ZFP_zfAllocCacheImplUnregister(enableFlag());
278 }
279 };
280};
281
282template<typename T_ZFObject>
283T_ZFObject *_ZFP_Obj_AllocCk<T_ZFObject, 1>::CanAlloc(void) {
284 if(&T_ZFObject::_ZFP_zfAllocCacheIvk != T_ZFObject::zfsuper::_ZFP_zfAllocCacheIvk) {
285 return _ZFP_zfAllocCache<T_ZFObject>::Alloc();
286 }
287 else {
288 return _ZFP_Obj_AllocCk<T_ZFObject, 1>::Alloc();
289 }
290}
291
292// ============================================================
293template<typename T_ZFObject> void _ZFP_zfweakCk(T_ZFObject &t);
322template<typename T_ZFObject, typename T_ZFObject2>
323inline void zfRetainChange(ZF_IN T_ZFObject &obj, ZF_IN T_ZFObject2 const &v) {
325 _ZFP_zfweakCk(obj);
326 ZFObject *tmp = zfcast(ZFObject *, obj);
327 zfunsafe_zfRetain(obj = v);
330}
331
332template<typename T_ZFObject, typename T_ZFObject2>
333inline void zfunsafe_zfRetainChange(ZF_IN T_ZFObject &obj, ZF_IN T_ZFObject2 const &v) {
334 _ZFP_zfweakCk(obj);
335 ZFObject *tmp = zfcast(ZFObject *, obj);
336 zfunsafe_zfRetain(obj = v);
338}
339
341#endif // #ifndef _ZFI_ZFObjectRetain_h_
342
#define ZFLIB_ZFCore
used to export symbols
Definition ZFCoreEnvDef.h:30
#define ZFCoreMutexUnlock()
see ZFCoreMutexLock
Definition ZFCoreMutex.h:58
#define ZFCoreMutexLock()
internal use only
Definition ZFCoreMutex.h:51
#define ZF_IN
dummy macro that shows the param used as required input
Definition ZFCoreTypeDef_ClassType.h:180
#define zfclassNotPOD
shows the class is not a POD type, you should not memset it or declare it in stack or copy value by c...
Definition ZFCoreTypeDef_ClassType.h:48
#define ZF_IN_OUT
dummy macro that shows the param used as required input and output
Definition ZFCoreTypeDef_ClassType.h:196
_ZFT_t_zfbool zfbool
bool type
Definition ZFCoreTypeDef_CoreType.h:103
_ZFT_t_zfindex zfindex
similar to size_t, used for index and size only
Definition ZFCoreTypeDef_CoreType.h:154
#define zffalse
bool false type
Definition ZFCoreTypeDef_CoreType.h:111
#define zfnull
same as NULL, defined for future use
Definition ZFCoreTypeDef_CoreType.h:88
#define ZFUNUSED(v)
explicit declare v is not used
Definition ZFCoreUtilMacro.h:388
#define ZF_NAMESPACE_GLOBAL_BEGIN
begin namespace ZFFramework
Definition ZFNamespace.h:97
#define ZF_NAMESPACE_GLOBAL_END
end namespace ZFFramework
Definition ZFNamespace.h:98
#define zfcast(T_To, obj)
safely cast ZFObject types, return null if not desired type
Definition ZFObjectCast.h:28
base class of all objects
void zfunsafe_zfRetainChange(T_ZFObject &obj, T_ZFObject2 const &v)
no lock version of zfRetainChange, use with caution
Definition ZFObjectRetain.h:333
#define zfunsafe_zfRelease(obj)
no lock version of zfRelease, use with caution
Definition ZFObjectRetain.h:151
#define zfunsafe_zfRetain(obj)
no lock version of zfRetain, use with caution
Definition ZFObjectRetain.h:131
void zfRetainChange(T_ZFObject &obj, T_ZFObject2 const &v)
util to release property's old value, retain new value, then set to property
Definition ZFObjectRetain.h:323
void zfAllocCacheRemoveAll(void)
remove all object cache, see ZFALLOC_CACHE_RELEASE
base class of all objects
Definition ZFObjectCore.h:209