ZFFramework
 
Loading...
Searching...
No Matches
ZFPropertyDeclare.h
Go to the documentation of this file.
1
5
6#ifndef _ZFI_ZFPropertyDeclare_h_
7#define _ZFI_ZFPropertyDeclare_h_
8
9#include "ZFMethodDeclare.h"
10#include "ZFObjectUtil.h"
11#include "zfsynchronize.h"
12
13ZF_NAMESPACE_GLOBAL_BEGIN
14
15zfclassFwd ZFClass;
16// ============================================================
20#define ZFPropertyAccess(OwnerClass, Name) ((const ZFProperty *)OwnerClass::_ZFP_Prop_##Name())
21
25extern ZFLIB_ZFCore const ZFProperty *ZFPropertyForName(
26 ZF_IN const zfstring &classNameOrFullName
27 , ZF_IN const zfstring &propertyName
28 );
29
30// ============================================================
32#define ZFPropertyNoInitValue
33#define _ZFP_PropInitV(...) __VA_ARGS__
34
35// ============================================================
104#define ZFPROPERTY_RETAIN(Type, Name, ...) \
105 ZFPROPERTY_RETAIN_DETAIL( \
106 Type, Name, _ZFP_PropInitV(__VA_ARGS__), \
107 public, public)
108
110#define ZFPROPERTY_RETAIN_READONLY(Type, Name, InitValueOrEmpty) \
111 ZFPROPERTY_RETAIN_DETAIL( \
112 Type, Name, InitValueOrEmpty, \
113 protected, public)
114
116#define ZFPROPERTY_RETAIN_DETAIL( \
117 Type, Name, InitValueOrEmpty, \
118 SetterAccessType, GetterAccessType) \
119 _ZFP_ZFPROPERTY_GETTER_RETAIN(GetterAccessType, Type, Name) \
120 \
121 _ZFP_ZFPROPERTY_SETTER_RETAIN(SetterAccessType, Type, Name) \
122 _ZFP_ZFPROPERTY_DECLARE_RETAIN(Type, zftTraits<Type>::TrType::ClassData()->classNameFull(), Name, \
123 InitValueOrEmpty) \
124 public:
125
126// ============================================================
128#define ZFPROPERTY_ASSIGN(Type, Name, ...) \
129 ZFPROPERTY_ASSIGN_DETAIL( \
130 Type, Name, _ZFP_PropInitV(__VA_ARGS__), \
131 public, public)
132
134#define ZFPROPERTY_ASSIGN_READONLY(Type, Name, InitValueOrEmpty) \
135 ZFPROPERTY_ASSIGN_DETAIL( \
136 Type, Name, InitValueOrEmpty, \
137 protected, public)
138
140#define ZFPROPERTY_ASSIGN_DETAIL( \
141 Type, Name, InitValueOrEmpty, \
142 SetterAccessType, GetterAccessType) \
143 _ZFP_ZFPROPERTY_GETTER_ASSIGN(GetterAccessType, Type, Name) \
144 \
145 _ZFP_ZFPROPERTY_SETTER_ASSIGN(SetterAccessType, Type, Name) \
146 _ZFP_ZFPROPERTY_DECLARE_ASSIGN(Type, ZFTypeId<zftTraits<Type>::TrNoRef>::TypeId(), Name, \
147 InitValueOrEmpty) \
148 public:
149
150// ============================================================
208#define ZFPROPERTY_ON_INIT_DECLARE(Type, Name) \
209 public: \
210 static zfbool _ZFP_propLExt_##Name(void) {return zftrue;} \
211 _ZFP_ZFPROPERTY_LIFE_CYCLE_OVERRIDE_DECLARE(Type, Name, OnInit, ZFM_EMPTY)
212
213#define ZFPROPERTY_ON_INIT_DECLARE_NO_AUTO_INIT(Type, Name) \
214 public: \
215 static zfbool _ZFP_propLExt_##Name(void) {return zffalse;} \
216 _ZFP_ZFPROPERTY_LIFE_CYCLE_OVERRIDE_DECLARE(Type, Name, OnInit, ZFM_EMPTY)
217
218#define ZFPROPERTY_ON_INIT_DEFINE(OwnerClass, Type, Name) \
219 _ZFP_ZFPROPERTY_LIFE_CYCLE_OVERRIDE_DEFINE(OwnerClass, Type, Name, OnInit, ZFM_EMPTY, ZFM_EXPAND( \
220 OwnerClass::ClassData()->_ZFP_ZFClass_propertyAutoInitRegister(OwnerClass::_ZFP_Prop_##Name()); \
221 if(OwnerClass::_ZFP_propLExt_##Name()) { \
222 OwnerClass::ClassData()->_ZFP_ZFClass_propertyInitStepRegister(OwnerClass::_ZFP_Prop_##Name()); \
223 } \
224 ))
225
226#define ZFPROPERTY_ON_INIT_INLINE(Type, Name) \
227 _ZFP_ZFPROPERTY_LIFE_CYCLE_OVERRIDE_INLINE(Type, Name, OnInit, ZFM_EMPTY, ZFM_EXPAND( \
228 zfself::ClassData()->_ZFP_ZFClass_propertyAutoInitRegister(zfself::_ZFP_Prop_##Name()); \
229 zfself::ClassData()->_ZFP_ZFClass_propertyInitStepRegister(zfself::_ZFP_Prop_##Name()); \
230 ))
231
232#define ZFPROPERTY_ON_INIT_INLINE_NO_AUTO_INIT(Type, Name) \
233 _ZFP_ZFPROPERTY_LIFE_CYCLE_OVERRIDE_INLINE(Type, Name, OnInit, ZFM_EMPTY, ZFM_EXPAND( \
234 zfself::ClassData()->_ZFP_ZFClass_propertyInitStepRegister(zfself::_ZFP_Prop_##Name()); \
235 ))
236
238#define ZFPROPERTY_ON_UPDATE_DECLARE(Type, Name) \
239 _ZFP_ZFPROPERTY_LIFE_CYCLE_OVERRIDE_DECLARE(Type, Name, OnUpdate, ZFM_EMPTY)
240
241#define ZFPROPERTY_ON_UPDATE_DEFINE(OwnerClass, Type, Name) \
242 _ZFP_ZFPROPERTY_LIFE_CYCLE_OVERRIDE_DEFINE(OwnerClass, Type, Name, OnUpdate, ZFM_EMPTY, ZFM_EMPTY())
243
244#define ZFPROPERTY_ON_UPDATE_INLINE(Type, Name) \
245 _ZFP_ZFPROPERTY_LIFE_CYCLE_OVERRIDE_INLINE(Type, Name, OnUpdate, ZFM_EMPTY, ZFM_EMPTY())
246
248#define ZFPROPERTY_ON_ATTACH_DECLARE(Type, Name) \
249 _ZFP_ZFPROPERTY_LIFE_CYCLE_OVERRIDE_DECLARE(Type, Name, OnAttach, ZFM_EXPAND)
250
251#define ZFPROPERTY_ON_ATTACH_DEFINE(OwnerClass, Type, Name) \
252 _ZFP_ZFPROPERTY_LIFE_CYCLE_OVERRIDE_DEFINE(OwnerClass, Type, Name, OnAttach, ZFM_EXPAND, ZFM_EMPTY())
253
254#define ZFPROPERTY_ON_ATTACH_INLINE(Type, Name) \
255 _ZFP_ZFPROPERTY_LIFE_CYCLE_OVERRIDE_INLINE(Type, Name, OnAttach, ZFM_EXPAND, ZFM_EMPTY())
256
258#define ZFPROPERTY_ON_DETACH_DECLARE(Type, Name) \
259 _ZFP_ZFPROPERTY_LIFE_CYCLE_OVERRIDE_DECLARE(Type, Name, OnDetach, ZFM_EXPAND)
260
261#define ZFPROPERTY_ON_DETACH_DEFINE(OwnerClass, Type, Name) \
262 _ZFP_ZFPROPERTY_LIFE_CYCLE_OVERRIDE_DEFINE(OwnerClass, Type, Name, OnDetach, ZFM_EXPAND, ZFM_EMPTY())
263
264#define ZFPROPERTY_ON_DETACH_INLINE(Type, Name) \
265 _ZFP_ZFPROPERTY_LIFE_CYCLE_OVERRIDE_INLINE(Type, Name, OnDetach, ZFM_EXPAND, ZFM_EMPTY())
266
267// ============================================================
268template<typename T_ZFObject>
269zfclassNotPOD _ZFP_PropRVH { // RetainValueHolder
270public:
271 void value(ZF_IN ZFObject *obj) {
272 T_ZFObject old = this->_value;
273 this->_value = zfcast(T_ZFObject, zfunsafe_zfRetain(obj));
274 zfunsafe_zfRelease(old);
275 }
276 T_ZFObject &value(void) {
277 return this->_value;
278 }
279public:
280 _ZFP_PropRVH(void)
281 : _value(zfnull)
282 {
283 }
284 template<typename T_ZFObject2>
285 _ZFP_PropRVH(ZF_IN T_ZFObject2 obj)
286 : _value(zfunsafe_zfRetain(zfcast(T_ZFObject, obj)))
287 {
288 }
289 ~_ZFP_PropRVH(void) {
290 zfunsafe_zfRelease(this->_value);
291 }
292private:
293 T_ZFObject _value;
294};
295template<typename T_Type>
296zfclassNotPOD _ZFP_PropRVSC_r { // RawValueStoreCallback_retain
297public:
298 static void f(
299 ZF_IN void *rawValueStoreToken
300 , ZF_IN ZFObject *value
301 ) {
302 ((_ZFP_PropRVH<T_Type> *)rawValueStoreToken)->value(value);
303 }
304};
305template<typename T_Type>
306zfclassNotPOD _ZFP_PropRVSC_a { // RawValueStoreCallback_assign
307public:
308 static void *f(
309 ZF_IN void *rawValueStoreToken
310 , ZF_IN const void *value
311 ) {
312 *(T_Type *)rawValueStoreToken = *(T_Type *)value;
313 return rawValueStoreToken;
314 }
315};
316
317template<typename T_Type, int isZFObject = zftIsZFObject(typename zftTraits<T_Type>::TrType)>
318zfclassNotPOD _ZFP_PropWeak {
319public:
320 static inline ZFObject *v(ZF_IN T_Type const &p) {
321 return zfnull;
322 }
323};
324template<typename T_Type>
325zfclassNotPOD _ZFP_PropWeak<T_Type, 1> {
326public:
327 static inline ZFObject *v(ZF_IN T_Type const &p) {
328 return zfcast(ZFObject *, p);
329 }
330};
331template<>
332zfclassNotPOD _ZFP_PropWeak<zfany, 0> {
333public:
334 static inline ZFObject *v(ZF_IN zfany const &p) {
335 return zfcast(ZFObject *, p);
336 }
337};
338template<typename T_Type>
339zfclassNotPOD _ZFP_PropWeak<zfanyT<T_Type>, 0> {
340public:
341 static inline ZFObject *v(ZF_IN zfanyT<T_Type> const &p) {
342 return zfcast(ZFObject *, p);
343 }
344};
345
346#define _ZFP_ZFPROPERTY_DECLARE_REGISTER_RETAIN(Type, ZFTypeId_noneOrType, Name, \
347 propertyClassOfRetainProperty) \
348 public: \
349 static ZFProperty *_ZFP_Prop_##Name(void) { \
350 static _ZFP_ZFPropertyRegisterHolder _propertyInfoHolder(zffalse \
351 , zffalse \
352 , zfnull \
353 , zfself::ClassData() \
354 , zftext(#Name) \
355 , zftext(#Type) \
356 , ZFTypeId_noneOrType \
357 , ZFMethodAccessDetail_1(zfself, Name \
358 , ZFMP_IN(Type const &, propertyValue) \
359 ) \
360 , ZFMethodAccessDetail_0(zfself, Name) \
361 , zfnull \
362 , zfnull \
363 , propertyClassOfRetainProperty \
364 , zfself::_ZFP_propCbAccessed_##Name \
365 , zfself::_ZFP_propCbIsInit_##Name \
366 , zfself::_ZFP_propCbReset_##Name \
367 , zfnull \
368 , zfnull \
369 , zfself::_ZFP_propCbEnsureInit_##Name \
370 , zfself::_ZFP_propCbDel_##Name \
371 ); \
372 return _propertyInfoHolder.propertyInfo; \
373 }
374#define _ZFP_ZFPROPERTY_DECLARE_REGISTER_ASSIGN(Type, ZFTypeId_noneOrType, Name, \
375 propertyClassOfRetainProperty) \
376 public: \
377 static ZFProperty *_ZFP_Prop_##Name(void) { \
378 static _ZFP_ZFPropertyRegisterHolder _propertyInfoHolder(zffalse \
379 , zffalse \
380 , zfnull \
381 , zfself::ClassData() \
382 , zftext(#Name) \
383 , zftext(#Type) \
384 , ZFTypeId_noneOrType \
385 , ZFMethodAccessDetail_1(zfself, Name \
386 , ZFMP_IN(Type const &, propertyValue) \
387 ) \
388 , ZFMethodAccessDetail_0(zfself, Name) \
389 , zfnull \
390 , zfnull \
391 , propertyClassOfRetainProperty \
392 , zfself::_ZFP_propCbAccessed_##Name \
393 , zfself::_ZFP_propCbIsInit_##Name \
394 , zfself::_ZFP_propCbReset_##Name \
395 , zfnull \
396 , zfnull \
397 , zfself::_ZFP_propCbEnsureInit_##Name \
398 , zfself::_ZFP_propCbDel_##Name \
399 ); \
400 return _propertyInfoHolder.propertyInfo; \
401 }
402
403#define _ZFP_ZFPROPERTY_VALUE_DECLARE_RETAIN(Type, ZFTypeId_noneOrType, Name, \
404 InitValueOrEmpty) \
405 public: \
406 \
407 typedef Type _ZFP_PropVT_##Name; \
408 typedef zfauto _ZFP_PropHT_##Name; \
409 \
410 private: \
411 zffinal zfclassNotPOD _ZFP_PropV_##Name { \
412 public: \
413 _ZFP_PropV_##Name(void) \
414 : _ZFP_v(zfnull) \
415 { \
416 zfself::_ZFP_Prop_##Name(); \
417 } \
418 ~_ZFP_PropV_##Name(void) { \
419 zfpoolDelete(this->_ZFP_v); \
420 } \
421 public: \
422 zfself::_ZFP_PropVT_##Name &_ZFP_init( \
423 ZF_IN ZFObject *owner \
424 , ZF_IN zfbool notifyOwnerAttach \
425 ) { \
426 if(!(this->_ZFP_v)) { \
427 this->_ZFP_v = zfpoolNew(_ZFP_PropRVH<zfself::_ZFP_PropVT_##Name>, InitValueOrEmpty); \
428 _ZFP_ZFPropertyLifeCycleCall_init_retain( \
429 zfself::_ZFP_Prop_##Name(), \
430 owner, \
431 zfcast(ZFObject *, this->_ZFP_v->value()), \
432 notifyOwnerAttach, \
433 _ZFP_PropRVSC_r<zfself::_ZFP_PropVT_##Name>::f, \
434 this->_ZFP_v); \
435 } \
436 return this->_ZFP_v->value(); \
437 } \
438 inline zfbool _ZFP_accessed(void) const { \
439 return (this->_ZFP_v != zfnull); \
440 } \
441 void _ZFP_dealloc( \
442 ZF_IN ZFObject *owner \
443 , ZF_IN zfbool notifyOwnerDetach \
444 ) { \
445 _ZFP_ZFPropertyLifeCycleCall_dealloc_retain( \
446 zfself::_ZFP_Prop_##Name(), \
447 owner, \
448 zfcast(ZFObject *, this->_ZFP_v->value()), \
449 notifyOwnerDetach); \
450 zfpoolDelete(this->_ZFP_v); \
451 this->_ZFP_v = zfnull; \
452 } \
453 public: \
454 _ZFP_PropRVH<zfself::_ZFP_PropVT_##Name> *_ZFP_v; \
455 }; \
456 zfself::_ZFP_PropV_##Name Name##_PropV; \
457 private: \
458 static zfbool _ZFP_propCbIsInit_##Name( \
459 ZF_IN const ZFProperty *property \
460 , ZF_IN zfany const &ownerObj \
461 , ZF_OUT_OPT zfauto *outInitValue \
462 ) { \
463 zfself *t = zfcast(zfself *, ownerObj); \
464 if(t->Name##_PropV._ZFP_accessed()) { \
465 zfself::_ZFP_PropV_##Name _holder; \
466 if(outInitValue != zfnull) { \
467 *outInitValue = _holder._ZFP_init(ownerObj, zffalse); \
468 } \
469 zfbool ret = (ZFObjectCompareValue( \
470 t->Name(), _holder._ZFP_init(ownerObj, zffalse)) \
471 == ZFCompareEqual); \
472 _holder._ZFP_dealloc(ownerObj, zffalse); \
473 return ret; \
474 } \
475 else { \
476 return zftrue; \
477 } \
478 } \
479 public:
480#define _ZFP_ZFPROPERTY_VALUE_DECLARE_ASSIGN(Type, ZFTypeId_noneOrType, Name, \
481 InitValueOrEmpty) \
482 public: \
483 \
484 typedef Type _ZFP_PropVT_##Name; \
485 typedef Type _ZFP_PropHT_##Name; \
486 \
487 private: \
488 zffinal zfclassNotPOD _ZFP_PropV_##Name { \
489 public: \
490 _ZFP_PropV_##Name(void) \
491 : _ZFP_v(zfnull) \
492 { \
493 zfself::_ZFP_Prop_##Name(); \
494 } \
495 ~_ZFP_PropV_##Name(void) { \
496 zfpoolDelete(this->_ZFP_v); \
497 } \
498 public: \
499 zfself::_ZFP_PropVT_##Name &_ZFP_init( \
500 ZF_IN ZFObject *owner \
501 , ZF_IN zfbool notifyOwnerAttach \
502 ) { \
503 if(!(this->_ZFP_v)) { \
504 this->_ZFP_v = zfpoolNew(zfself::_ZFP_PropVT_##Name, InitValueOrEmpty); \
505 _ZFP_ZFPropertyLifeCycleCall_init_assign( \
506 zfself::_ZFP_Prop_##Name(), \
507 owner, \
508 this->_ZFP_v, \
509 notifyOwnerAttach, \
510 _ZFP_PropWeak<zfself::_ZFP_PropVT_##Name>::v(*(this->_ZFP_v))); \
511 } \
512 return (*(this->_ZFP_v)); \
513 } \
514 inline zfbool _ZFP_accessed(void) const { \
515 return (this->_ZFP_v != zfnull); \
516 } \
517 void _ZFP_dealloc( \
518 ZF_IN ZFObject *owner \
519 , ZF_IN zfbool notifyOwnerDetach \
520 ) { \
521 _ZFP_ZFPropertyLifeCycleCall_dealloc_assign( \
522 zfself::_ZFP_Prop_##Name(), \
523 owner, \
524 this->_ZFP_v, \
525 notifyOwnerDetach, \
526 _ZFP_PropWeak<zfself::_ZFP_PropVT_##Name>::v(*(this->_ZFP_v))); \
527 zfpoolDelete(this->_ZFP_v); \
528 this->_ZFP_v = zfnull; \
529 } \
530 public: \
531 zfself::_ZFP_PropVT_##Name *_ZFP_v; \
532 }; \
533 zfself::_ZFP_PropV_##Name Name##_PropV; \
534 private: \
535 static zfbool _ZFP_propCbIsInit_##Name( \
536 ZF_IN const ZFProperty *property \
537 , ZF_IN zfany const &ownerObj \
538 , ZF_OUT_OPT zfauto *outInitValue \
539 ) { \
540 zfself *t = zfcast(zfself *, ownerObj); \
541 if(t->Name##_PropV._ZFP_accessed()) { \
542 zfself::_ZFP_PropV_##Name _holder; \
543 if(outInitValue != zfnull) { \
544 ZFTypeId<zfself::_ZFP_PropVT_##Name>::ValueStore(*outInitValue, _holder._ZFP_init(ownerObj, zffalse)); \
545 } \
546 zfbool ret = (ZFComparerDefault( \
547 t->Name(), _holder._ZFP_init(ownerObj, zffalse)) \
548 == ZFCompareEqual); \
549 _holder._ZFP_dealloc(ownerObj, zffalse); \
550 return ret; \
551 } \
552 else { \
553 return zftrue; \
554 } \
555 } \
556 public:
557
558// ============================================================
559#define _ZFP_ZFPROPERTY_DECLARE_CALLBACK(Type, Name) \
560 private: \
561 static zfbool _ZFP_propCbAccessed_##Name( \
562 ZF_IN const ZFProperty *property \
563 , ZF_IN zfany const &ownerObj \
564 ) { \
565 return zfcast(zfself *, ownerObj)->Name##_PropV._ZFP_accessed(); \
566 } \
567 static void _ZFP_propCbReset_##Name( \
568 ZF_IN const ZFProperty *property \
569 , ZF_IN zfany const &owner \
570 ) { \
571 if(_ZFP_propCbAccessed_##Name(property, owner)) { \
572 owner->_ZFP_ZFObject_objectPropertyValueOnReset(zfself::_ZFP_Prop_##Name()); \
573 } \
574 zfcast(zfself *, owner)->Name##_PropV._ZFP_dealloc(owner, zftrue); \
575 } \
576 static void _ZFP_propCbEnsureInit_##Name( \
577 ZF_IN const ZFProperty *property \
578 , ZF_IN zfany const &owner \
579 ) { \
580 zfcast(zfself *, owner)->Name##_PropV._ZFP_init(owner, zftrue); \
581 } \
582 static void _ZFP_propCbDel_##Name( \
583 ZF_IN const ZFProperty *property \
584 , ZF_IN zfany const &owner \
585 ) { \
586 zfcast(zfself *, owner)->Name##_PropV._ZFP_dealloc(owner, zffalse); \
587 } \
588 public:
589
590// ============================================================
591#define _ZFP_ZFPROPERTY_DECLARE_RETAIN(Type, ZFTypeId_noneOrType, Name, \
592 InitValueOrEmpty) \
593 _ZFP_ZFPROPERTY_DECLARE_REGISTER_RETAIN(Type, ZFTypeId_noneOrType, Name, \
594 zftTraits<Type>::TrType::ClassData()) \
595 _ZFP_ZFPROPERTY_VALUE_DECLARE_RETAIN(Type, ZFTypeId_noneOrType, Name, \
596 InitValueOrEmpty) \
597 _ZFP_ZFPROPERTY_DECLARE_CALLBACK(Type, Name)
598#define _ZFP_ZFPROPERTY_DECLARE_ASSIGN(Type, ZFTypeId_noneOrType, Name, \
599 InitValueOrEmpty) \
600 _ZFP_ZFPROPERTY_DECLARE_REGISTER_ASSIGN(Type, ZFTypeId_noneOrType, Name, \
601 zfnull) \
602 _ZFP_ZFPROPERTY_VALUE_DECLARE_ASSIGN(Type, ZFTypeId_noneOrType, Name, \
603 InitValueOrEmpty) \
604 _ZFP_ZFPROPERTY_DECLARE_CALLBACK(Type, Name)
605
606// ============================================================
607#define _ZFP_ZFPROPERTY_SETTER_RETAIN(AccessType, Type, Name) \
608 AccessType: \
609 _ZFP_ZFMETHOD_INLINE( \
610 notAutoRegister \
611 , AccessType, ZFMethodTypeVirtual, S \
612 , void, Name \
613 , _ZFP_MtdP_EXPAND(ZFMP_IN(Type const &, propertyValue)) \
614 , _ZFP_ZFMP_DUMMY() \
615 , _ZFP_ZFMP_DUMMY() \
616 , _ZFP_ZFMP_DUMMY() \
617 , _ZFP_ZFMP_DUMMY() \
618 , _ZFP_ZFMP_DUMMY() \
619 , _ZFP_ZFMP_DUMMY() \
620 , _ZFP_ZFMP_DUMMY() \
621 ) { \
622 zfsynchronizeLock(this); \
623 zfbool accessed = Name##_PropV._ZFP_accessed(); \
624 ZFObject *valueOld = zfcast(ZFObject *, Name##_PropV._ZFP_init(this->toObject(), zffalse)); \
625 _ZFP_ZFPropertyLifeCycleCall_setter_retain( \
626 zfself::_ZFP_Prop_##Name(), \
627 this->toObject(), \
628 accessed, \
629 valueOld, \
630 zfcast(ZFObject *, propertyValue), \
631 _ZFP_PropRVSC_r<zfself::_ZFP_PropVT_##Name>::f, \
632 Name##_PropV._ZFP_v); \
633 zfsynchronizeUnlock(this); \
634 } \
635 public:
636#define _ZFP_ZFPROPERTY_SETTER_ASSIGN(AccessType, Type, Name) \
637 AccessType: \
638 _ZFP_ZFMETHOD_INLINE( \
639 notAutoRegister \
640 , AccessType, ZFMethodTypeVirtual, S \
641 , void, Name \
642 , _ZFP_MtdP_EXPAND(ZFMP_IN(Type const &, propertyValue)) \
643 , _ZFP_ZFMP_DUMMY() \
644 , _ZFP_ZFMP_DUMMY() \
645 , _ZFP_ZFMP_DUMMY() \
646 , _ZFP_ZFMP_DUMMY() \
647 , _ZFP_ZFMP_DUMMY() \
648 , _ZFP_ZFMP_DUMMY() \
649 , _ZFP_ZFMP_DUMMY() \
650 ) { \
651 zfsynchronizeLock(this); \
652 zfbool accessed = Name##_PropV._ZFP_accessed(); \
653 Type valueOld = Name##_PropV._ZFP_init(this->toObject(), zffalse); \
654 _ZFP_ZFPropertyLifeCycleCall_setter_assign( \
655 zfself::_ZFP_Prop_##Name(), \
656 this->toObject(), \
657 accessed, \
658 &valueOld, \
659 &propertyValue, \
660 _ZFP_PropRVSC_a<zfself::_ZFP_PropVT_##Name>::f, \
661 Name##_PropV._ZFP_v, \
662 _ZFP_PropWeak<zfself::_ZFP_PropVT_##Name>::v(valueOld), \
663 _ZFP_PropWeak<zfself::_ZFP_PropVT_##Name>::v(propertyValue)); \
664 zfsynchronizeUnlock(this); \
665 } \
666 public:
667#define _ZFP_ZFPROPERTY_GETTER_RETAIN(AccessType, Type, Name) \
668 AccessType: \
669 _ZFP_ZFMETHOD_INLINE( \
670 notAutoRegister \
671 , AccessType, ZFMethodTypeVirtual, G \
672 , Type const &, Name \
673 , _ZFP_ZFMP_DUMMY() \
674 , _ZFP_ZFMP_DUMMY() \
675 , _ZFP_ZFMP_DUMMY() \
676 , _ZFP_ZFMP_DUMMY() \
677 , _ZFP_ZFMP_DUMMY() \
678 , _ZFP_ZFMP_DUMMY() \
679 , _ZFP_ZFMP_DUMMY() \
680 , _ZFP_ZFMP_DUMMY() \
681 ) { \
682 zfsynchronize(this); \
683 return Name##_PropV._ZFP_init(this->toObject(), zftrue); \
684 } \
685 public:
686#define _ZFP_ZFPROPERTY_GETTER_ASSIGN(AccessType, Type, Name) \
687 AccessType: \
688 _ZFP_ZFMETHOD_INLINE( \
689 notAutoRegister \
690 , AccessType, ZFMethodTypeVirtual, G \
691 /* ZFTAG_TRICKS: return non const ref, but use const ref in reflection */ \
692 , Type &, Name \
693 , _ZFP_ZFMP_DUMMY() \
694 , _ZFP_ZFMP_DUMMY() \
695 , _ZFP_ZFMP_DUMMY() \
696 , _ZFP_ZFMP_DUMMY() \
697 , _ZFP_ZFMP_DUMMY() \
698 , _ZFP_ZFMP_DUMMY() \
699 , _ZFP_ZFMP_DUMMY() \
700 , _ZFP_ZFMP_DUMMY() \
701 ) { \
702 zfsynchronize(this); \
703 return Name##_PropV._ZFP_init(this->toObject(), zftrue); \
704 } \
705 public:
706
707// ============================================================
708#define _ZFP_ZFPROPERTY_LIFE_CYCLE_OVERRIDE_INLINE(Type, Name, lifeCycleName, constFix, extraRegStep) \
709 private: \
710 zfclassNotPOD _ZFP_propLReg_##lifeCycleName##_##Name { \
711 public: \
712 _ZFP_propLReg_##lifeCycleName##_##Name(void) { \
713 static zfbool needInit = zftrue; \
714 if(needInit) { \
715 needInit = zffalse; \
716 _ZFP_ZFPropertyLifeCycleRegister( \
717 zftext(#lifeCycleName), \
718 zfself::_ZFP_Prop_##Name(), \
719 zfself::ClassData(), \
720 zfself::_ZFP_propLI_##lifeCycleName##_##Name); \
721 extraRegStep \
722 } \
723 } \
724 }; \
725 _ZFP_propLReg_##lifeCycleName##_##Name _ZFP_propLReg_##lifeCycleName##_##Name; \
726 static void _ZFP_propLI_##lifeCycleName##_##Name( \
727 ZF_IN ZFObject *propertyOwnerObject \
728 , ZF_IN const ZFProperty *property \
729 , ZF_IN void *propertyValue \
730 , ZF_IN const void *propertyValueOld \
731 , ZF_IN ZFObject *propertyLifeCycleUserData \
732 ) { \
733 zfcast(zfself *, propertyOwnerObject)->zfself::_ZFP_propL_##lifeCycleName##_##Name( \
734 *(constFix(const) zfself::_ZFP_PropHT_##Name *)propertyValue, \
735 *(zfself::_ZFP_PropHT_##Name *)propertyValueOld); \
736 } \
737 public: \
738 zffinal void _ZFP_propL_##lifeCycleName##_##Name( \
739 ZF_IN zfself::_ZFP_PropHT_##Name constFix(const) &propertyValue, \
740 ZF_IN zfself::_ZFP_PropHT_##Name const &propertyValueOld)
741#define _ZFP_ZFPROPERTY_LIFE_CYCLE_OVERRIDE_DECLARE(Type, Name, lifeCycleName, constFix) \
742 public: \
743 zffinal void _ZFP_propL_##lifeCycleName##_##Name( \
744 ZF_IN zfself::_ZFP_PropHT_##Name constFix(const) &propertyValue, \
745 ZF_IN zfself::_ZFP_PropHT_##Name const &propertyValueOld);
746#define _ZFP_ZFPROPERTY_LIFE_CYCLE_OVERRIDE_DEFINE(OwnerClass, Type, Name, lifeCycleName, constFix, extraRegStep) \
747 ZF_STATIC_REGISTER_INIT(propL_##OwnerClass##_##lifeCycleName##_##Name) { \
748 _ZFP_ZFPropertyLifeCycleRegister( \
749 zftext(#lifeCycleName), \
750 OwnerClass::_ZFP_Prop_##Name(), \
751 OwnerClass::ClassData(), \
752 a); \
753 extraRegStep \
754 } \
755 public: \
756 static void a( \
757 ZF_IN ZFObject *propertyOwnerObject \
758 , ZF_IN const ZFProperty *property \
759 , ZF_IN void *propertyValue \
760 , ZF_IN const void *propertyValueOld \
761 , ZF_IN ZFObject *propertyLifeCycleUserData \
762 ) { \
763 zfcast(OwnerClass *, propertyOwnerObject)->OwnerClass::_ZFP_propL_##lifeCycleName##_##Name( \
764 *(constFix(const) OwnerClass::_ZFP_PropHT_##Name *)propertyValue, \
765 *(OwnerClass::_ZFP_PropHT_##Name *)propertyValueOld); \
766 } \
767 ZF_STATIC_REGISTER_END(propL_##OwnerClass##_##lifeCycleName##_##Name) \
768 void OwnerClass::_ZFP_propL_##lifeCycleName##_##Name( \
769 ZF_IN zfself::_ZFP_PropHT_##Name constFix(const) &propertyValue, \
770 ZF_IN zfself::_ZFP_PropHT_##Name const &propertyValueOld)
771
772extern ZFLIB_ZFCore void _ZFP_ZFPropertyLifeCycleRegister(
773 ZF_IN const zfchar *lifeCycleName
774 , ZF_IN const ZFProperty *property
775 , ZF_IN const ZFClass *ownerClass
776 , ZF_IN _ZFP_PropLifeCycleWrapper propertyLifeCycleWrapper
777 );
778extern ZFLIB_ZFCore void _ZFP_ZFPropertyLifeCycleUnregister(
779 ZF_IN const zfchar *lifeCycleName
780 , ZF_IN const ZFProperty *property
781 , ZF_IN const ZFClass *ownerClass
782 );
783extern ZFLIB_ZFCore void _ZFP_ZFPropertyLifeCycleCall_init_retain(
784 ZF_IN const ZFProperty *property
785 , ZF_IN ZFObject *propertyOwnerObject
786 , ZF_IN ZFObject *value
787 , ZF_IN zfbool notifyOwnerAttach
788 , ZF_IN void (*rawValueStoreCallback)(
789 ZF_IN void *rawValueStoreToken
790 , ZF_IN ZFObject *value
791 )
792 , ZF_IN void *rawValueStoreToken
793 );
794extern ZFLIB_ZFCore void _ZFP_ZFPropertyLifeCycleCall_init_assign(
795 ZF_IN const ZFProperty *property
796 , ZF_IN ZFObject *propertyOwnerObject
797 , ZF_IN void *value
798 , ZF_IN zfbool notifyOwnerAttach
799 , ZF_IN ZFObject *weakProp
800 );
801extern ZFLIB_ZFCore void _ZFP_ZFPropertyLifeCycleCall_dealloc_retain(
802 ZF_IN const ZFProperty *property
803 , ZF_IN ZFObject *propertyOwnerObject
804 , ZF_IN ZFObject *value
805 , ZF_IN zfbool notifyOwnerDetach
806 );
807extern ZFLIB_ZFCore void _ZFP_ZFPropertyLifeCycleCall_dealloc_assign(
808 ZF_IN const ZFProperty *property
809 , ZF_IN ZFObject *propertyOwnerObject
810 , ZF_IN void *value
811 , ZF_IN zfbool notifyOwnerDetach
812 , ZF_IN ZFObject *weakProp
813 );
814extern ZFLIB_ZFCore void _ZFP_ZFPropertyLifeCycleCall_setter_retain(
815 ZF_IN const ZFProperty *property
816 , ZF_IN ZFObject *propertyOwnerObject
817 , ZF_IN zfbool accessed
818 , ZF_IN ZFObject *propertyValueOld
819 , ZF_IN ZFObject *propertyValueNew
820 , ZF_IN void (*rawValueStoreCallback)(
821 ZF_IN void *rawValueStoreToken
822 , ZF_IN ZFObject *value
823 )
824 , ZF_IN void *rawValueStoreToken
825 );
826extern ZFLIB_ZFCore void _ZFP_ZFPropertyLifeCycleCall_setter_assign(
827 ZF_IN const ZFProperty *property
828 , ZF_IN ZFObject *propertyOwnerObject
829 , ZF_IN zfbool accessed
830 , ZF_IN void *propertyValueOld
831 , ZF_IN const void *propertyValueNew
832 , ZF_IN void *(*rawValueStoreCallback)(
833 ZF_IN void *rawValueStoreToken
834 , ZF_IN const void *value
835 )
836 , ZF_IN void *rawValueStoreToken
837 , ZF_IN ZFObject *weakPropOld
838 , ZF_IN ZFObject *weakPropNew
839 );
840
841ZF_NAMESPACE_GLOBAL_END
842#endif // #ifndef _ZFI_ZFPropertyDeclare_h_
843
ZFLIB_ZFCore
#define ZFLIB_ZFCore
used to export symbols
Definition ZFCoreEnvDef.h:30
zfchar
_ZFT_t_zfchar zfchar
char wrapper
Definition ZFCoreTypeDef_CharType.h:17
ZF_IN
#define ZF_IN
dummy macro that shows the param used as required input
Definition ZFCoreTypeDef_ClassType.h:180
zfclassNotPOD
#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
zfclassFwd
#define zfclassFwd
forward declaration of a class type
Definition ZFCoreTypeDef_ClassType.h:31
zfbool
_ZFT_t_zfbool zfbool
bool type
Definition ZFCoreTypeDef_CoreType.h:103
zfnull
#define zfnull
same as NULL, defined for future use
Definition ZFCoreTypeDef_CoreType.h:88
zfstring
zft_zfstring< zfchar > zfstring
see zft_zfstring
Definition ZFCoreTypeDef_StringType.h:15
ZFMethodDeclare.h
ZFMethod declaration.
ZF_NAMESPACE_GLOBAL_BEGIN
#define ZF_NAMESPACE_GLOBAL_BEGIN
begin namespace ZFFramework
Definition ZFNamespace.h:97
ZF_NAMESPACE_GLOBAL_END
#define ZF_NAMESPACE_GLOBAL_END
end namespace ZFFramework
Definition ZFNamespace.h:98
zfcast
#define zfcast(T_To, obj)
safely cast ZFObject types, return null if not desired type
Definition ZFObjectCast.h:28
zfunsafe_zfRelease
#define zfunsafe_zfRelease(obj)
no lock version of zfRelease, use with caution
Definition ZFObjectRetain.h:151
zfunsafe_zfRetain
#define zfunsafe_zfRetain(obj)
no lock version of zfRetain, use with caution
Definition ZFObjectRetain.h:131
ZFObjectUtil.h
utilities for ZFObject
ZFPropertyForName
const ZFProperty * ZFPropertyForName(const zfstring &classNameOrFullName, const zfstring &propertyName)
get property by name, or null if not registered
ZFClass
ZFObject's class info.
Definition ZFClass.h:67
ZFObject
base class of all objects
Definition ZFObjectCore.h:209
ZFProperty
info for a property for ZFObject, see ZFPROPERTY_RETAIN for more info
Definition ZFProperty.h:28
zfany
util method to cast ZFObject types freely
Definition zfany.h:35
zfanyT
see zfany
Definition zfany.h:106
zfsynchronize.h
type define for synchronize logic in ZFFramework