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