ZFFramework
 
Loading...
Searching...
No Matches
zfweak.h
Go to the documentation of this file.
1
5
6#ifndef _ZFI_zfweak_h_
7#define _ZFI_zfweak_h_
8
9#include "zfweak_fwd.h"
10
12
13// ============================================================
53public:
54 zfweak(void) : _ZFP_obj(zfnull) {}
55 zfweak(ZF_IN zfweak const &obj) : _ZFP_obj(zfRetain(obj._ZFP_obj)) {}
56 zfweak(ZF_IN ZFObject *obj) : _ZFP_obj(obj ? zfRetain(obj->_ZFP_ZFObject_weakHolder()) : zfnull) {}
57 template<typename T_ZFObject>
58 zfweak(ZF_IN T_ZFObject const &obj) {
59 ZFObject *t = _ZFP_zfanyCast(obj);
60 _ZFP_obj = t ? zfRetain(t->_ZFP_ZFObject_weakHolder()) : zfnull;
61 }
62 ~zfweak(void) {
63 zfRelease(_ZFP_obj);
64 }
65
66public:
67 inline zfweak &operator = (ZF_IN zfweak const &obj) {
68 this->set(obj);
69 return *this;
70 }
71 template<typename T_ZFObject>
72 inline zfweak &operator = (ZF_IN T_ZFObject const &obj) {
73 this->set(obj);
74 return *this;
75 }
76
77public:
78 template<typename T_ZFObject>
79 inline zfbool operator == (ZF_IN T_ZFObject const &obj) const {
80 return this->toObject() == _ZFP_zfanyCast(obj);
81 }
82 template<typename T_ZFObject>
83 inline zfbool operator != (ZF_IN T_ZFObject const &obj) const {
84 return this->toObject() != _ZFP_zfanyCast(obj);
85 }
86
87public:
88 inline ZFObject *operator -> (void) const {
89 return this->toObject();
90 }
91 inline operator zfbool (void) const {
92 return (zfbool)_ZFP_obj;
93 }
94 inline operator ZFObject * (void) const {
95 return this->toObject();
96 }
97 template<typename T_ZFObject>
98 inline operator T_ZFObject * (void) const {
99 return zfcast(T_ZFObject *, this->toObject());
100 }
101
102public:
103 static const ZFClass *ClassData(void) {
104 return ZFObject::ClassData();
105 }
107
108public:
112 inline zfbool valid(void) const {
113 return this->toObject() != zfnull;
114 }
115
119 inline zfany get(void) const {
120 return _ZFP_obj ? _ZFP_obj->get().toObject() : zfnull;
121 }
122
125 template<typename T_ZFObject>
126 void set(ZF_IN T_ZFObject const &obj) {
127 ZFObject *t = _ZFP_zfanyCast(obj);
128 _ZFP_I_zfweak *old = _ZFP_obj;
129 _ZFP_obj = (t ? zfRetain(t->_ZFP_ZFObject_weakHolder()) : zfnull);
130 zfRelease(old);
131 }
132
135 void set(ZF_IN const zfweak &obj) {
136 this->set(obj.toObject());
137 }
138
141 void set(ZF_IN zfnullT const &) {
142 _ZFP_I_zfweak *old = _ZFP_obj;
143 _ZFP_obj = zfnull;
144 zfRelease(old);
145 }
146
147public:
151 inline ZFObject *toObject(void) const {
152 return _ZFP_obj ? _ZFP_obj->get().toObject() : zfnull;
153 }
154
157 template<typename T_ZFObject>
158 inline T_ZFObject to(void) const {
159 return zfcast(T_ZFObject, this->toObject());
160 }
161
165 const zfany &asAny(void) const {
166 return _ZFP_obj;
167 }
168
169private:
170 zfanyT<_ZFP_I_zfweak> _ZFP_obj;
171};
173 if(v) {
174 s += "[weak]";
175 v.toObject()->objectInfoT(s);
176 }
177 else {
178 s += ZFTOKEN_zfnull;
179 }
180})
182 return ZFObjectCompare(v0.toObject(), v1.toObject());
183 })
186
187// ============================================================
191template<typename T_ZFObjectBase>
194public:
195 zfweakT(void) : zfweak() {}
196 zfweakT(ZF_IN zfweak const &obj) : zfweak(obj) {}
197 zfweakT(ZF_IN zfweakT<T_ZFObjectBase> const &obj) : zfweak((zfweak const &)obj) {}
198 zfweakT(ZF_IN ZFObject *obj) : zfweak(obj) {}
199 template<typename T_ZFObject>
200 zfweakT(ZF_IN T_ZFObject const &obj) : zfweak(obj) {}
201
202public:
203 inline zfweakT<T_ZFObjectBase> &operator = (ZF_IN zfweak const &obj) {
204 this->set(obj);
205 return *this;
206 }
207 inline zfweakT<T_ZFObjectBase> &operator = (ZF_IN zfweakT<T_ZFObjectBase> const &obj) {
208 this->set(obj);
209 return *this;
210 }
211 template<typename T_ZFObject>
212 inline zfweakT<T_ZFObjectBase> &operator = (ZF_IN T_ZFObject const &obj) {
213 this->set(obj);
214 return *this;
215 }
216
217public:
218 template<typename T_ZFObject>
219 inline zfbool operator == (ZF_IN T_ZFObject const &obj) const {
220 return this->toObject() == _ZFP_zfanyCast(obj);
221 }
222 template<typename T_ZFObject>
223 inline zfbool operator != (ZF_IN T_ZFObject const &obj) const {
224 return this->toObject() != _ZFP_zfanyCast(obj);
225 }
226
227public:
228 inline T_ZFObjectBase *operator -> (void) const {
229 return zfcast(T_ZFObjectBase *, this->toObject());
230 }
231
232public:
233 inline ZFObject *toObject(void) const { // required for _ZFP_zfanyCast to work
234 return zfweak::toObject();
235 }
236
237public:
238 static const ZFClass *ClassData(void) {
239 return T_ZFObjectBase::ClassData();
240 }
242};
243ZFOUTPUT_TYPE_TEMPLATE(typename T_ZFObject, zfweakT<T_ZFObject>, {
244 if(v) {
245 s += "[weak]";
246 v.toObject()->objectInfoT(s);
247 }
248 else {
249 s += ZFTOKEN_zfnull;
250 }
251})
253template<typename T_ZFObject>
255public:
256 enum {
257 TypeIdRegistered = 1,
258 TypeIdSerializable = 1,
259 };
260 static inline const zfstring &TypeId(void) {
262 }
263 static inline const ZFClass *TypeIdClass(void) {
264 return v_zfweak::ClassData();
265 }
267 virtual zfbool typeIdSerializable(void) const {
268 return TypeIdSerializable;
269 }
271 virtual const zfstring &typeId(void) const {
272 return TypeId();
273 }
275 virtual const ZFClass *typeIdClass(void) const {
276 return TypeIdClass();
277 }
278 static zfbool ValueStore(
279 ZF_OUT zfauto &obj
280 , ZF_IN zfweakT<T_ZFObject> const &v
281 ) {
282 return ZFTypeId<zfweak>::ValueStore(obj, v);
283 }
284 template<typename T_Access = zfweakT<T_ZFObject>
285 , int T_Mode = ((zftTraits<typename zftTraits<T_Access>::TrNoRef>::TrIsPtr
286 && !zftIsSame<typename zftTraits<T_Access>::TrNoRef, zfweakT<T_ZFObject> >::Value) ? 1
287 : ((zftTraits<typename zftTraits<T_Access>::TrNoRef>::TrIsPtr
288 && zftIsSame<typename zftTraits<T_Access>::TrNoRef, zfweakT<T_ZFObject> >::Value
289 && !zftTraits<T_Access>::TrIsRef) ? 2 : 0))
290 , typename T_Fix = void
291 >
292 zfclassNotPOD Value {
293 public:
294 static zfbool zfvAccessAvailable(ZF_IN_OUT zfauto &obj) {
296 }
297 static T_Access zfvAccess(ZF_IN_OUT zfauto &obj) {
298 // zfweakT ensured safe for reinterpret cast
300 }
301 static void zfvAccessFinish(ZF_IN_OUT zfauto &obj) {
303 }
304 };
305 template<typename T_Access>
306 zfclassNotPOD Value<T_Access, 1> {
307 public:
308 static zfbool zfvAccessAvailable(ZF_IN_OUT zfauto &obj) {
310 }
311 static typename zftTraits<T_Access>::TrNoRef zfvAccess(ZF_IN_OUT zfauto &obj) {
312 // zfweakT ensured safe for reinterpret cast
314 }
315 static void zfvAccessFinish(ZF_IN_OUT zfauto &obj) {
317 }
318 };
319public:
321 virtual zfbool genericValueStore(ZF_OUT zfauto &obj, ZF_IN const void *v) const {
322 return ValueStore(obj, *(const zfweakT<T_ZFObject> *)v);
323 }
325 virtual void *genericAccess(ZF_IN_OUT zfauto &obj) const {
326 if(!Value<zfweakT<T_ZFObject> >::zfvAccessAvailable(obj)) {
327 return zfnull;
328 }
329 return (void *)zfnew(zfweakT<T_ZFObject>, Value<zfweakT<T_ZFObject> >::zfvAccess(obj));
330 }
332 virtual void genericAccessFinish(ZF_IN_OUT zfauto &obj, ZF_IN void *v) const {
334 Value<zfweakT<T_ZFObject> >::zfvAccessFinish(obj);
335 }
337 virtual ZFCoreArrayBase *genericArrayNew(void) const {
339 }
340};
342
344// ============================================================
345template<typename T_ZFObject>
346inline zfbool operator == (ZF_IN T_ZFObject *obj, ZF_IN zfweak const &e) {
347 return e.toObject() == _ZFP_zfanyCast(obj);
348}
349template<typename T_ZFObject>
350inline zfbool operator != (ZF_IN T_ZFObject *obj, ZF_IN zfweak const &e) {
351 return e.toObject() != _ZFP_zfanyCast(obj);
352}
353
354// ============================================================
355template<typename T_ZFObject, typename T_ZFObjectBase>
356inline zfbool operator == (ZF_IN T_ZFObject *obj, ZF_IN zfweakT<T_ZFObjectBase> const &e) {
357 return e.toObject() == _ZFP_zfanyCast(obj);
358}
359template<typename T_ZFObject, typename T_ZFObjectBase>
360inline zfbool operator != (ZF_IN T_ZFObject *obj, ZF_IN zfweakT<T_ZFObjectBase> const &e) {
361 return e.toObject() != _ZFP_zfanyCast(obj);
362}
364
365// ============================================================
366template<typename T_ZFObject>
367zfclassNotPOD _ZFP_zfweakCkT {
368public:
369 static inline void zfweakNotSupport(void) {}
370};
371template<> zfclassNotPOD _ZFP_zfweakCkT<zfweak> {};
372template<typename T_ZFObject> zfclassNotPOD _ZFP_zfweakCkT<zfweakT<T_ZFObject> > {};
373template<typename T_ZFObject>
374inline void _ZFP_zfweakCk(T_ZFObject &t) {
375 _ZFP_zfweakCkT<typename zftTraits<T_ZFObject>::TrNoRef>::zfweakNotSupport();
376}
377
379#endif // #ifndef _ZFI_zfweak_h_
380
#define ZFCOMPARER_DEFAULT_DECLARE(T_Comparable0, T_Comparable1, compareAction)
declare a template specialization for ZFComparerDefault
Definition ZFComparer.h:264
#define ZFLIB_ZFCore
used to export symbols
Definition ZFCoreEnvDef.h:30
#define zfclassLikePOD
shows the class is not a POD type, but you may use it like a POD except memset it to 0
Definition ZFCoreTypeDef_ClassType.h:41
#define zfextend
dummy macro shows class inherit from another
Definition ZFCoreTypeDef_ClassType.h:53
#define zfdelete(instance)
same as delete defined for future use
Definition ZFCoreTypeDef_ClassType.h:91
#define zfoverride
dummy macro shows that method override parent's method
Definition ZFCoreTypeDef_ClassType.h:58
#define ZF_IN
dummy macro that shows the param used as required input
Definition ZFCoreTypeDef_ClassType.h:180
#define ZF_OUT
dummy macro that shows the param used as required output
Definition ZFCoreTypeDef_ClassType.h:188
#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
#define zfnew(Type,...)
same as new defined for future use
Definition ZFCoreTypeDef_ClassType.h:89
#define zfnullT
type for zfnull, can be used for function overload
Definition ZFCoreTypeDef_CoreType.h:85
_ZFT_t_zfbool zfbool
bool type
Definition ZFCoreTypeDef_CoreType.h:103
#define zfnull
same as NULL, defined for future use
Definition ZFCoreTypeDef_CoreType.h:88
#define ZFOUTPUT_TYPE(T_Type, outputAction)
declare your custom type conversion to string, convenient for debug
Definition ZFCoreTypeDef_OtherType.h:221
#define ZFOUTPUT_TYPE_TEMPLATE(T_typenameList, T_Type, outputAction)
see ZFOUTPUT_TYPE
Definition ZFCoreTypeDef_OtherType.h:262
#define ZFTOKEN_zfnull
string tokens
Definition ZFCoreTypeDef_OtherType.h:16
zft_zfstring< zfchar > zfstring
see zft_zfstring
Definition ZFCoreTypeDef_StringType.h:15
#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 zfRelease(obj)
release an object, see ZFObject
Definition ZFObjectRetain.h:148
#define zfRetain(obj)
retain an object, see ZFObject
Definition ZFObjectRetain.h:128
ZFCompareResult ZFObjectCompare(ZFObject *const &e0, ZFObject *const &e1)
util method to compare two ZFObject, return ZFCompareEqual if both null, return ZFCompareUncomparable...
Definition ZFObjectUtil.h:21
#define ZFTYPEID_ACCESS_ONLY_REG(ZFLIB_, TypeName, Type,...)
see ZFTYPEID_DECLARE
Definition ZFTypeIdDeclare.h:205
#define ZFTYPEID_ACCESS_ONLY_DECLARE(ZFLIB_, TypeName, Type)
see ZFTYPEID_DECLARE
Definition ZFTypeIdDeclare.h:195
ZFObject's class info.
Definition ZFClass.h:66
dummy base for ZFCoreArray
Definition ZFCoreArray.h:162
light weight array
Definition ZFCoreArray.h:331
base class of all objects
Definition ZFObjectCore.h:205
static const ZFClass * ClassData(void)
get class info
Definition ZFObjectCore.h:207
static zfbool zfvAccessAvailable(zfauto &obj)
try access as raw value, see ZFTypeId::Value
static T_Access zfvAccess(zfauto &obj)
try access as raw value, see ZFTypeId::Value
static void zfvAccessFinish(zfauto &obj)
finish access as raw value, see ZFTypeId::Value
type data traits for ZFTYPEID_DECLARE
Definition ZFTypeIdFwd.h:117
static const zfstring & TypeId(void)
get type id, or return ZFTypeId_none if not registered
static zfbool ValueStore(zfauto &obj, T_Type const &v)
store the value to wrapper object
base protocol for ZFTypeId
Definition ZFTypeIdFwd.h:24
static const ZFClass * ClassData(void)
get class info
Definition zfweak.h:184
util method to cast ZFObject types freely
Definition zfany.h:35
ZFObject * toObject(void) const
get the holded object
Definition zfany.h:88
see zfany
Definition zfany.h:109
a ZFObject holder which would release content object automatically when destroyed
Definition zfautoFwd.h:34
T_Type TrNoRef
remove reference
Definition ZFCoreUtilTemplate.h:112
weak reference to ZFObject
Definition zfweak.h:51
zfany get(void) const
get the holded object
Definition zfweak.h:119
const zfany & asAny(void) const
access as zfany
Definition zfweak.h:165
void set(T_ZFObject const &obj)
set the holded object
Definition zfweak.h:126
ZFObject * toObject(void) const
get the holded object
Definition zfweak.h:151
T_ZFObject to(void) const
cast by zfcast
Definition zfweak.h:158
void set(const zfweak &obj)
set the holded object
Definition zfweak.h:135
zfbool valid(void) const
true if the holded object is not null
Definition zfweak.h:112
void set(zft_zfnullT const &)
set the holded object
Definition zfweak.h:141
see zfweak
Definition zfweak.h:192
#define zfcast(T_To, obj)
safely cast ZFObject types, return null if not desired type
Definition zfcast.h:28
weak reference to ZFObject