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(Type, Name, _ZFP_PropInitV(__VA_ARGS__), public, public)
105
107#define ZFPROPERTY_RETAIN_READONLY(Type, Name, InitValueOrEmpty) \
108 ZFPROPERTY_RETAIN_DETAIL(Type, Name, InitValueOrEmpty, protected, public)
109
111#define ZFPROPERTY_RETAIN_DETAIL(Type, Name, InitValueOrEmpty, SetterAccessType, GetterAccessType) \
112 _ZFP_ZFPROPERTY_GETTER_RETAIN(GetterAccessType, Type, Name) \
113 \
114 _ZFP_ZFPROPERTY_SETTER_RETAIN(SetterAccessType, Type, Name) \
115 _ZFP_ZFPROPERTY_DECLARE_RETAIN(Type, zftTraits<Type>::TrType::ClassData()->classNameFull(), Name, InitValueOrEmpty) \
116 public:
117
118// ============================================================
120#define ZFPROPERTY_ASSIGN(Type, Name, ...) \
121 ZFPROPERTY_ASSIGN_DETAIL(Type, Name, _ZFP_PropInitV(__VA_ARGS__), public, public)
122
124#define ZFPROPERTY_ASSIGN_READONLY(Type, Name, InitValueOrEmpty) \
125 ZFPROPERTY_ASSIGN_DETAIL(Type, Name, InitValueOrEmpty, protected, public)
126
128#define ZFPROPERTY_ASSIGN_DETAIL(Type, Name, InitValueOrEmpty, SetterAccessType, GetterAccessType) \
129 _ZFP_ZFPROPERTY_GETTER_ASSIGN(GetterAccessType, Type, Name) \
130 \
131 _ZFP_ZFPROPERTY_SETTER_ASSIGN(SetterAccessType, Type, Name) \
132 _ZFP_ZFPROPERTY_DECLARE_ASSIGN(Type, ZFTypeId<zftTraits<Type>::TrNoRef>::TypeId(), Name, InitValueOrEmpty) \
133 public:
134
135// ============================================================
199#define ZFPROPERTY_ON_INIT_DECLARE(Type, Name) \
200 public: \
201 ZFLIB_HIDDEN static zfbool _ZFP_propLExt_##Name(void) {return zftrue;} \
202 _ZFP_ZFPROPERTY_LIFE_CYCLE_OVERRIDE_DECLARE(Type, Name, OnInit, ZFM_EMPTY)
203
204#define ZFPROPERTY_ON_INIT_DECLARE_NO_AUTO_INIT(Type, Name) \
205 public: \
206 ZFLIB_HIDDEN static zfbool _ZFP_propLExt_##Name(void) {return zffalse;} \
207 _ZFP_ZFPROPERTY_LIFE_CYCLE_OVERRIDE_DECLARE(Type, Name, OnInit, ZFM_EMPTY)
208
209#define ZFPROPERTY_ON_INIT_DEFINE(OwnerClass, Type, Name) \
210 _ZFP_ZFPROPERTY_LIFE_CYCLE_OVERRIDE_DEFINE(OwnerClass, Type, Name, OnInit, ZFM_EMPTY, ZFM_EXPAND( \
211 OwnerClass::ClassData()->_ZFP_ZFClass_propertyAutoInitRegister(OwnerClass::_ZFP_Prop_##Name()); \
212 if(OwnerClass::_ZFP_propLExt_##Name()) { \
213 OwnerClass::ClassData()->_ZFP_ZFClass_propertyInitStepRegister(OwnerClass::_ZFP_Prop_##Name()); \
214 } \
215 ))
216
217#define ZFPROPERTY_ON_INIT_INLINE(Type, Name) \
218 _ZFP_ZFPROPERTY_LIFE_CYCLE_OVERRIDE_INLINE(Type, Name, OnInit, ZFM_EMPTY, ZFM_EXPAND( \
219 zfself::ClassData()->_ZFP_ZFClass_propertyAutoInitRegister(zfself::_ZFP_Prop_##Name()); \
220 zfself::ClassData()->_ZFP_ZFClass_propertyInitStepRegister(zfself::_ZFP_Prop_##Name()); \
221 ))
222
223#define ZFPROPERTY_ON_INIT_INLINE_NO_AUTO_INIT(Type, Name) \
224 _ZFP_ZFPROPERTY_LIFE_CYCLE_OVERRIDE_INLINE(Type, Name, OnInit, ZFM_EMPTY, ZFM_EXPAND( \
225 zfself::ClassData()->_ZFP_ZFClass_propertyInitStepRegister(zfself::_ZFP_Prop_##Name()); \
226 ))
227
229#define ZFPROPERTY_ON_UPDATE_DECLARE(Type, Name) \
230 _ZFP_ZFPROPERTY_LIFE_CYCLE_OVERRIDE_DECLARE(Type, Name, OnUpdate, ZFM_EMPTY)
231
232#define ZFPROPERTY_ON_UPDATE_DEFINE(OwnerClass, Type, Name) \
233 _ZFP_ZFPROPERTY_LIFE_CYCLE_OVERRIDE_DEFINE(OwnerClass, Type, Name, OnUpdate, ZFM_EMPTY, ZFM_EMPTY())
234
235#define ZFPROPERTY_ON_UPDATE_INLINE(Type, Name) \
236 _ZFP_ZFPROPERTY_LIFE_CYCLE_OVERRIDE_INLINE(Type, Name, OnUpdate, ZFM_EMPTY, ZFM_EMPTY())
237
239#define ZFPROPERTY_ON_ATTACH_DECLARE(Type, Name) \
240 _ZFP_ZFPROPERTY_LIFE_CYCLE_OVERRIDE_DECLARE(Type, Name, OnAttach, ZFM_EXPAND)
241
242#define ZFPROPERTY_ON_ATTACH_DEFINE(OwnerClass, Type, Name) \
243 _ZFP_ZFPROPERTY_LIFE_CYCLE_OVERRIDE_DEFINE(OwnerClass, Type, Name, OnAttach, ZFM_EXPAND, ZFM_EMPTY())
244
245#define ZFPROPERTY_ON_ATTACH_INLINE(Type, Name) \
246 _ZFP_ZFPROPERTY_LIFE_CYCLE_OVERRIDE_INLINE(Type, Name, OnAttach, ZFM_EXPAND, ZFM_EMPTY())
247
249#define ZFPROPERTY_ON_DETACH_DECLARE(Type, Name) \
250 _ZFP_ZFPROPERTY_LIFE_CYCLE_OVERRIDE_DECLARE(Type, Name, OnDetach, ZFM_EXPAND)
251
252#define ZFPROPERTY_ON_DETACH_DEFINE(OwnerClass, Type, Name) \
253 _ZFP_ZFPROPERTY_LIFE_CYCLE_OVERRIDE_DEFINE(OwnerClass, Type, Name, OnDetach, ZFM_EXPAND, ZFM_EMPTY())
254
255#define ZFPROPERTY_ON_DETACH_INLINE(Type, Name) \
256 _ZFP_ZFPROPERTY_LIFE_CYCLE_OVERRIDE_INLINE(Type, Name, OnDetach, ZFM_EXPAND, ZFM_EMPTY())
257
258// ============================================================
259#define _ZFP_PropInvalid ((zfuint)0xdeadc0de) // magic number to indicates property not accessed
260
261template<typename T_Type>
262zfclassNotPOD _ZFP_PropRVH { // RetainValueHolder
263public:
264 static void VS( // RawValueStoreCallback
265 ZF_IN_OUT void *rawValueStoreToken
266 , ZF_IN ZFObject *value
267 ) {
268 ((_ZFP_PropRVH<T_Type> *)rawValueStoreToken)->Set(value);
269 }
270public:
271 void Set(void) {
272 if(!this->VA()) {
273 zfnewPlacement(&(_ZFP_v.v), T_Type);
274 }
275 }
276 void Set(ZF_IN ZFObject *obj) {
277 if(this->VA()) {
278 T_Type old = this->Get();
279 this->Get() = zfcast(T_Type, zfunsafe_zfobjRetain(obj));
280 zfunsafe_zfobjRelease(old);
281 }
282 else {
283 zfnewPlacement(&(_ZFP_v.v), T_Type, zfcast(T_Type, zfunsafe_zfobjRetain(obj)));
284 }
285 }
286 T_Type &Get(void) {
287 return (T_Type &)_ZFP_v.v;
288 }
289 void Reset(void) {
290 zfdeletePlacement(&(this->Get()));
291 _ZFP_v.a = _ZFP_PropInvalid;
292 }
293 zfbool VA(void) const { // ValueAccessed
294 return (_ZFP_v.a != _ZFP_PropInvalid);
295 }
296public:
297 _ZFP_PropRVH(void)
298 {
299 _ZFP_v.a = _ZFP_PropInvalid;
300 }
301 ~_ZFP_PropRVH(void) {
302 if(this->VA()) {
303 zfunsafe_zfobjRelease(this->Get());
304 zfdeletePlacement(&(this->Get()));
305 }
306 }
307private:
308 union {
309 zfuint a;
310 zfbyte v[sizeof(T_Type)];
311 } _ZFP_v;
312};
313template<typename T_Type>
314zfclassNotPOD _ZFP_PropAVH { // AssignValueHolder
315public:
316 static void *VS( // RawValueStoreCallback
317 ZF_IN_OUT void *rawValueStoreToken
318 , ZF_IN const void *value
319 ) {
320 _ZFP_PropAVH<T_Type> *t = (_ZFP_PropAVH<T_Type> *)rawValueStoreToken;
321 t->Set(*(const T_Type *)value);
322 return &(t->Get());
323 }
324public:
325 void Set(void) {
326 if(!this->VA()) {
327 zfnewPlacement(&(_ZFP_v.v), T_Type);
328 }
329 }
330 void Set(ZF_IN const T_Type &value) {
331 if(this->VA()) {
332 this->Get() = value;
333 }
334 else {
335 zfnewPlacement(&(_ZFP_v.v), T_Type, value);
336 }
337 }
338 T_Type &Get(void) {
339 return (T_Type &)_ZFP_v.v;
340 }
341 void Reset(void) {
342 zfdeletePlacement(&(this->Get()));
343 _ZFP_v.a = _ZFP_PropInvalid;
344 }
345 zfbool VA(void) const {
346 return (_ZFP_v.a != _ZFP_PropInvalid);
347 }
348public:
349 _ZFP_PropAVH(void)
350 {
351 _ZFP_v.a = _ZFP_PropInvalid;
352 }
353 ~_ZFP_PropAVH(void) {
354 if(this->VA()) {
355 zfdeletePlacement(&(this->Get()));
356 }
357 }
358private:
359 union {
360 zfuint a;
361 zfbyte v[sizeof(T_Type)];
362 } _ZFP_v;
363};
364
365template<typename T_Type, int isZFObject = zftIsZFObject(typename zftTraits<T_Type>::TrType)>
366zfclassNotPOD _ZFP_PropWeak {
367public:
368 static inline ZFObject *v(ZF_IN T_Type const &p) {
369 return zfnull;
370 }
371};
372template<typename T_Type>
373zfclassNotPOD _ZFP_PropWeak<T_Type, 1> {
374public:
375 static inline ZFObject *v(ZF_IN T_Type const &p) {
376 return zfcast(ZFObject *, p);
377 }
378};
379template<>
380zfclassNotPOD _ZFP_PropWeak<zfany, 0> {
381public:
382 static inline ZFObject *v(ZF_IN zfany const &p) {
383 return zfcast(ZFObject *, p);
384 }
385};
386template<typename T_Type>
387zfclassNotPOD _ZFP_PropWeak<zfanyT<T_Type>, 0> {
388public:
389 static inline ZFObject *v(ZF_IN zfanyT<T_Type> const &p) {
390 return zfcast(ZFObject *, p);
391 }
392};
393
394#define _ZFP_ZFPROPERTY_DECLARE_REGISTER_RETAIN(Type, ZFTypeId_noneOrType, Name, propertyClassOfRetainProperty) \
395 public: \
396 static ZFProperty *_ZFP_Prop_##Name(void) { \
397 static _ZFP_ZFPropertyRegisterHolder d(zffalse \
398 , zffalse \
399 , zftrue \
400 , zftrue \
401 , zfnull \
402 , zfself::ClassData() \
403 , zftext(#Name) \
404 , zftext(#Type) \
405 , ZFTypeId_noneOrType \
406 , ZFMethodAccessDetail_1(zfself, Name \
407 , ZFMP_IN(Type const &, propertyValue) \
408 ) \
409 , ZFMethodAccessDetail_0(zfself, Name) \
410 , propertyClassOfRetainProperty \
411 , zfself::_ZFP_propCbAccessed_##Name \
412 , zfself::_ZFP_propCbIsInit_##Name \
413 , zfself::_ZFP_propCbReset_##Name \
414 , zfnull \
415 , zfnull \
416 , zfself::_ZFP_propCbEnsureInit_##Name \
417 , zfself::_ZFP_propCbDel_##Name \
418 ); \
419 return d.propertyInfo; \
420 }
421#define _ZFP_ZFPROPERTY_DECLARE_REGISTER_ASSIGN(Type, ZFTypeId_noneOrType, Name, propertyClassOfRetainProperty) \
422 public: \
423 static ZFProperty *_ZFP_Prop_##Name(void) { \
424 static _ZFP_ZFPropertyRegisterHolder d(zffalse \
425 , zffalse \
426 , zftrue \
427 , zftrue \
428 , zfnull \
429 , zfself::ClassData() \
430 , zftext(#Name) \
431 , zftext(#Type) \
432 , ZFTypeId_noneOrType \
433 , ZFMethodAccessDetail_1(zfself, Name \
434 , ZFMP_IN(Type const &, propertyValue) \
435 ) \
436 , ZFMethodAccessDetail_0(zfself, Name) \
437 , propertyClassOfRetainProperty \
438 , zfself::_ZFP_propCbAccessed_##Name \
439 , zfself::_ZFP_propCbIsInit_##Name \
440 , zfself::_ZFP_propCbReset_##Name \
441 , zfnull \
442 , zfnull \
443 , zfself::_ZFP_propCbEnsureInit_##Name \
444 , zfself::_ZFP_propCbDel_##Name \
445 ); \
446 return d.propertyInfo; \
447 }
448
449#define _ZFP_ZFPROPERTY_VALUE_DECLARE_RETAIN(Type, ZFTypeId_noneOrType, Name, InitValueOrEmpty) \
450 public: \
451 \
452 typedef Type _ZFP_PropVT_##Name; \
453 typedef zfauto _ZFP_PropHT_##Name; \
454 \
455 private: \
456 zfclassNotPOD ZFLIB_HIDDEN _ZFP_PropV_##Name : zfextend _ZFP_PropRVH<_ZFP_PropVT_##Name> { \
457 public: \
458 _ZFP_PropV_##Name(void) \
459 { \
460 zfself::_ZFP_Prop_##Name(); \
461 } \
462 public: \
463 zfself::_ZFP_PropVT_##Name &Init( \
464 ZF_IN ZFObject *owner \
465 , ZF_IN zfbool notifyOwnerAttach \
466 ) { \
467 if(!this->VA()) { \
468 ZFObjectLocker(owner); \
469 if(!this->VA()) { \
470 this->Set(InitValueOrEmpty); \
471 _ZFP_ZFPropertyLifeCycleCall_init_retain( \
472 zfself::_ZFP_Prop_##Name() \
473 , owner \
474 , zfcast(ZFObject *, this->Get()) \
475 , notifyOwnerAttach \
476 , _ZFP_PropRVH<_ZFP_PropVT_##Name>::VS \
477 , this \
478 ); \
479 } \
480 return this->Get(); \
481 } \
482 else { \
483 return this->Get(); \
484 } \
485 } \
486 void Dealloc( \
487 ZF_IN ZFObject *owner \
488 , ZF_IN zfbool notifyOwnerDetach \
489 ) { \
490 if(this->VA()) { \
491 _ZFP_ZFPropertyLifeCycleCall_dealloc_retain( \
492 zfself::_ZFP_Prop_##Name() \
493 , owner \
494 , zfcast(ZFObject *, this->Get()) \
495 , notifyOwnerDetach \
496 ); \
497 this->Reset(); \
498 } \
499 } \
500 }; \
501 zfself::_ZFP_PropV_##Name Name##_PropV; \
502 private: \
503 ZFLIB_HIDDEN static zfbool _ZFP_propCbIsInit_##Name( \
504 ZF_IN const ZFProperty *property \
505 , ZF_IN zfany const &ownerObj \
506 , ZF_OUT_OPT zfauto *outInitValue \
507 ) { \
508 zfself *t = zfcastNoExt(zfself *, ownerObj); \
509 if(t && t->Name##_PropV.VA()) { \
510 zfself::_ZFP_PropV_##Name _holder; \
511 if(outInitValue != zfnull) { \
512 *outInitValue = _holder.Init(ownerObj, zffalse); \
513 } \
514 zfbool ret = (ZFObjectCompareValue( \
515 t->Name(), _holder.Init(ownerObj, zffalse)) \
516 == ZFCompareEqual); \
517 _holder.Dealloc(ownerObj, zffalse); \
518 return ret; \
519 } \
520 else { \
521 return zftrue; \
522 } \
523 } \
524 public:
525#define _ZFP_ZFPROPERTY_VALUE_DECLARE_ASSIGN(Type, ZFTypeId_noneOrType, Name, \
526 InitValueOrEmpty) \
527 public: \
528 \
529 typedef Type _ZFP_PropVT_##Name; \
530 typedef Type _ZFP_PropHT_##Name; \
531 \
532 private: \
533 zfclassNotPOD ZFLIB_HIDDEN _ZFP_PropV_##Name : zfextend _ZFP_PropAVH<_ZFP_PropVT_##Name> { \
534 public: \
535 _ZFP_PropV_##Name(void) \
536 { \
537 zfself::_ZFP_Prop_##Name(); \
538 } \
539 public: \
540 zfself::_ZFP_PropVT_##Name &Init( \
541 ZF_IN ZFObject *owner \
542 , ZF_IN zfbool notifyOwnerAttach \
543 ) { \
544 if(!this->VA()) { \
545 ZFObjectLocker(owner); \
546 if(!this->VA()) { \
547 this->Set(InitValueOrEmpty); \
548 _ZFP_ZFPropertyLifeCycleCall_init_assign( \
549 zfself::_ZFP_Prop_##Name() \
550 , owner \
551 , &(this->Get()) \
552 , notifyOwnerAttach \
553 , _ZFP_PropWeak<zfself::_ZFP_PropVT_##Name>::v(this->Get()) \
554 ); \
555 } \
556 return this->Get(); \
557 } \
558 else { \
559 return this->Get(); \
560 } \
561 } \
562 void Dealloc( \
563 ZF_IN ZFObject *owner \
564 , ZF_IN zfbool notifyOwnerDetach \
565 ) { \
566 if(this->VA()) { \
567 _ZFP_ZFPropertyLifeCycleCall_dealloc_assign( \
568 zfself::_ZFP_Prop_##Name() \
569 , owner \
570 , &(this->Get()) \
571 , notifyOwnerDetach \
572 , _ZFP_PropWeak<zfself::_ZFP_PropVT_##Name>::v(this->Get()) \
573 ); \
574 this->Reset(); \
575 } \
576 } \
577 }; \
578 zfself::_ZFP_PropV_##Name Name##_PropV; \
579 private: \
580 ZFLIB_HIDDEN static zfbool _ZFP_propCbIsInit_##Name( \
581 ZF_IN const ZFProperty *property \
582 , ZF_IN zfany const &ownerObj \
583 , ZF_OUT_OPT zfauto *outInitValue \
584 ) { \
585 zfself *t = zfcastNoExt(zfself *, ownerObj); \
586 if(t && t->Name##_PropV.VA()) { \
587 zfself::_ZFP_PropV_##Name _holder; \
588 if(outInitValue != zfnull) { \
589 ZFTypeId<zfself::_ZFP_PropVT_##Name>::ValueStore(*outInitValue, _holder.Init(ownerObj, zffalse)); \
590 } \
591 zfbool ret = (ZFComparerDefault( \
592 t->Name(), _holder.Init(ownerObj, zffalse)) \
593 == ZFCompareEqual); \
594 _holder.Dealloc(ownerObj, zffalse); \
595 return ret; \
596 } \
597 else { \
598 return zftrue; \
599 } \
600 } \
601 public:
602
603// ============================================================
604#define _ZFP_ZFPROPERTY_DECLARE_CALLBACK(Type, Name) \
605 private: \
606 ZFLIB_HIDDEN static zfbool _ZFP_propCbAccessed_##Name( \
607 ZF_IN const ZFProperty *property \
608 , ZF_IN zfany const &ownerObj \
609 ) { \
610 zfself *t = zfcastNoExt(zfself *, ownerObj); \
611 return t && t->Name##_PropV.VA(); \
612 } \
613 ZFLIB_HIDDEN static void _ZFP_propCbReset_##Name( \
614 ZF_IN const ZFProperty *property \
615 , ZF_IN zfany const &owner \
616 ) { \
617 if(_ZFP_propCbAccessed_##Name(property, owner)) { \
618 owner->_ZFP_ZFObject_objectPropertyValueOnReset(zfself::_ZFP_Prop_##Name()); \
619 zfcast(zfself *, owner)->Name##_PropV.Dealloc(owner, zftrue); \
620 } \
621 } \
622 ZFLIB_HIDDEN static void _ZFP_propCbEnsureInit_##Name( \
623 ZF_IN const ZFProperty *property \
624 , ZF_IN zfany const &owner \
625 ) { \
626 zfcast(zfself *, owner)->Name##_PropV.Init(owner, zftrue); \
627 } \
628 ZFLIB_HIDDEN static void _ZFP_propCbDel_##Name( \
629 ZF_IN const ZFProperty *property \
630 , ZF_IN zfany const &owner \
631 ) { \
632 zfself *t = zfcastNoExt(zfself *, owner); \
633 if(t) { \
634 t->Name##_PropV.Dealloc(owner, zffalse); \
635 } \
636 } \
637 public:
638
639// ============================================================
640#define _ZFP_ZFPROPERTY_DECLARE_RETAIN(Type, ZFTypeId_noneOrType, Name, InitValueOrEmpty) \
641 _ZFP_ZFPROPERTY_DECLARE_REGISTER_RETAIN(Type, ZFTypeId_noneOrType, Name, zftTraits<Type>::TrType::ClassData()) \
642 _ZFP_ZFPROPERTY_VALUE_DECLARE_RETAIN(Type, ZFTypeId_noneOrType, Name, InitValueOrEmpty) \
643 _ZFP_ZFPROPERTY_DECLARE_CALLBACK(Type, Name)
644#define _ZFP_ZFPROPERTY_DECLARE_ASSIGN(Type, ZFTypeId_noneOrType, Name, InitValueOrEmpty) \
645 _ZFP_ZFPROPERTY_DECLARE_REGISTER_ASSIGN(Type, ZFTypeId_noneOrType, Name, zfnull) \
646 _ZFP_ZFPROPERTY_VALUE_DECLARE_ASSIGN(Type, ZFTypeId_noneOrType, Name, InitValueOrEmpty) \
647 _ZFP_ZFPROPERTY_DECLARE_CALLBACK(Type, Name)
648
649// ============================================================
650#define _ZFP_ZFPROPERTY_SETTER_RETAIN(AccessType, Type, Name) \
651 AccessType: \
652 _ZFP_ZFMETHOD_INLINE( \
653 notAutoRegister \
654 , AccessType, ZFMethodTypeVirtual, S \
655 , void, Name \
656 , _ZFP_mP_EXPAND(ZFMP_IN(Type const &, propertyValue)) \
657 , _ZFP_ZFMP_DUMMY() \
658 , _ZFP_ZFMP_DUMMY() \
659 , _ZFP_ZFMP_DUMMY() \
660 , _ZFP_ZFMP_DUMMY() \
661 , _ZFP_ZFMP_DUMMY() \
662 , _ZFP_ZFMP_DUMMY() \
663 , _ZFP_ZFMP_DUMMY() \
664 ) { \
665 ZFObjectLock(this); \
666 zfbool accessed = Name##_PropV.VA(); \
667 ZFObject *valueOld = zfcast(ZFObject *, Name##_PropV.Init(this->toObject(), zffalse)); \
668 _ZFP_ZFPropertyLifeCycleCall_setter_retain( \
669 zfself::_ZFP_Prop_##Name() \
670 , this->toObject() \
671 , accessed \
672 , valueOld \
673 , zfcast(ZFObject *, propertyValue) \
674 , _ZFP_PropRVH<zfself::_ZFP_PropVT_##Name>::VS \
675 , &Name##_PropV \
676 ); \
677 ZFObjectUnlock(this); \
678 } \
679 public:
680#define _ZFP_ZFPROPERTY_SETTER_ASSIGN(AccessType, Type, Name) \
681 AccessType: \
682 _ZFP_ZFMETHOD_INLINE( \
683 notAutoRegister \
684 , AccessType, ZFMethodTypeVirtual, S \
685 , void, Name \
686 , _ZFP_mP_EXPAND(ZFMP_IN(Type const &, propertyValue)) \
687 , _ZFP_ZFMP_DUMMY() \
688 , _ZFP_ZFMP_DUMMY() \
689 , _ZFP_ZFMP_DUMMY() \
690 , _ZFP_ZFMP_DUMMY() \
691 , _ZFP_ZFMP_DUMMY() \
692 , _ZFP_ZFMP_DUMMY() \
693 , _ZFP_ZFMP_DUMMY() \
694 ) { \
695 ZFObjectLock(this); \
696 zfbool accessed = Name##_PropV.VA(); \
697 Type valueOld = Name##_PropV.Init(this->toObject(), zffalse); \
698 _ZFP_ZFPropertyLifeCycleCall_setter_assign( \
699 zfself::_ZFP_Prop_##Name() \
700 , this->toObject() \
701 , accessed \
702 , &valueOld \
703 , &propertyValue \
704 , _ZFP_PropAVH<zfself::_ZFP_PropVT_##Name>::VS \
705 , &Name##_PropV \
706 , _ZFP_PropWeak<zfself::_ZFP_PropVT_##Name>::v(valueOld) \
707 , _ZFP_PropWeak<zfself::_ZFP_PropVT_##Name>::v(propertyValue) \
708 ); \
709 ZFObjectUnlock(this); \
710 } \
711 public:
712#define _ZFP_ZFPROPERTY_GETTER_RETAIN(AccessType, Type, Name) \
713 AccessType: \
714 _ZFP_ZFMETHOD_INLINE( \
715 notAutoRegister \
716 , AccessType, ZFMethodTypeVirtual, G \
717 , Type const &, Name \
718 , _ZFP_ZFMP_DUMMY() \
719 , _ZFP_ZFMP_DUMMY() \
720 , _ZFP_ZFMP_DUMMY() \
721 , _ZFP_ZFMP_DUMMY() \
722 , _ZFP_ZFMP_DUMMY() \
723 , _ZFP_ZFMP_DUMMY() \
724 , _ZFP_ZFMP_DUMMY() \
725 , _ZFP_ZFMP_DUMMY() \
726 ) { \
727 return Name##_PropV.Init(this->toObject(), zftrue); \
728 } \
729 public:
730#define _ZFP_ZFPROPERTY_GETTER_ASSIGN(AccessType, Type, Name) \
731 AccessType: \
732 _ZFP_ZFMETHOD_INLINE( \
733 notAutoRegister \
734 , AccessType, ZFMethodTypeVirtual, G \
735 /* ZFTAG_TRICKS: return non const ref, but use const ref in reflection */ \
736 , Type &, Name \
737 , _ZFP_ZFMP_DUMMY() \
738 , _ZFP_ZFMP_DUMMY() \
739 , _ZFP_ZFMP_DUMMY() \
740 , _ZFP_ZFMP_DUMMY() \
741 , _ZFP_ZFMP_DUMMY() \
742 , _ZFP_ZFMP_DUMMY() \
743 , _ZFP_ZFMP_DUMMY() \
744 , _ZFP_ZFMP_DUMMY() \
745 ) { \
746 return Name##_PropV.Init(this->toObject(), zftrue); \
747 } \
748 public:
749
750// ============================================================
751#define _ZFP_ZFPROPERTY_LIFE_CYCLE_OVERRIDE_INLINE(Type, Name, lifeCycleName, constFix, extraRegStep) \
752 private: \
753 zfclassNotPOD _ZFP_propLReg_##lifeCycleName##_##Name { \
754 public: \
755 _ZFP_propLReg_##lifeCycleName##_##Name(void) { \
756 static zfbool needInit = zftrue; \
757 if(needInit) { \
758 needInit = zffalse; \
759 zfself::_ZFP_Prop_##Name()->_ZFP_ZFPropertyLifeCycleRegister( \
760 ZFPropertyLifeCycle##lifeCycleName \
761 , zfself::ClassData() \
762 , zfself::_ZFP_propLI_##lifeCycleName##_##Name \
763 , zfnull \
764 ); \
765 extraRegStep \
766 } \
767 } \
768 }; \
769 _ZFP_propLReg_##lifeCycleName##_##Name _ZFP_propLReg_##lifeCycleName##_##Name; \
770 static void _ZFP_propLI_##lifeCycleName##_##Name( \
771 ZF_IN ZFObject *propertyOwnerObject \
772 , ZF_IN const ZFProperty *property \
773 , ZF_IN void *propertyValue \
774 , ZF_IN const void *propertyValueOld \
775 , ZF_IN ZFObject *propertyLifeCycleUserData \
776 ) { \
777 zfcast(zfself *, propertyOwnerObject)->zfself::_ZFP_propL_##lifeCycleName##_##Name( \
778 *(constFix(const) zfself::_ZFP_PropHT_##Name *)propertyValue \
779 , *(zfself::_ZFP_PropHT_##Name *)propertyValueOld \
780 ); \
781 } \
782 public: \
783 ZFLIB_HIDDEN zffinal void _ZFP_propL_##lifeCycleName##_##Name( \
784 ZF_IN zfself::_ZFP_PropHT_##Name constFix(const) &propertyValue \
785 , ZF_IN zfself::_ZFP_PropHT_##Name const &propertyValueOld \
786 )
787#define _ZFP_ZFPROPERTY_LIFE_CYCLE_OVERRIDE_DECLARE(Type, Name, lifeCycleName, constFix) \
788 public: \
789 ZFLIB_HIDDEN zffinal void _ZFP_propL_##lifeCycleName##_##Name( \
790 ZF_IN zfself::_ZFP_PropHT_##Name constFix(const) &propertyValue \
791 , ZF_IN zfself::_ZFP_PropHT_##Name const &propertyValueOld \
792 );
793#define _ZFP_ZFPROPERTY_LIFE_CYCLE_OVERRIDE_DEFINE(OwnerClass, Type, Name, lifeCycleName, constFix, extraRegStep) \
794 ZF_STATIC_REGISTER_INIT(propL_##OwnerClass##_##lifeCycleName##_##Name) { \
795 OwnerClass::_ZFP_Prop_##Name()->_ZFP_ZFPropertyLifeCycleRegister( \
796 ZFPropertyLifeCycle##lifeCycleName \
797 , OwnerClass::ClassData() \
798 , a \
799 , zfnull \
800 ); \
801 extraRegStep \
802 } \
803 public: \
804 static void a( \
805 ZF_IN ZFObject *propertyOwnerObject \
806 , ZF_IN const ZFProperty *property \
807 , ZF_IN void *propertyValue \
808 , ZF_IN const void *propertyValueOld \
809 , ZF_IN ZFObject *propertyLifeCycleUserData \
810 ) { \
811 zfcast(OwnerClass *, propertyOwnerObject)->OwnerClass::_ZFP_propL_##lifeCycleName##_##Name( \
812 *(constFix(const) OwnerClass::_ZFP_PropHT_##Name *)propertyValue \
813 , *(OwnerClass::_ZFP_PropHT_##Name *)propertyValueOld \
814 ); \
815 } \
816 ZF_STATIC_REGISTER_END(propL_##OwnerClass##_##lifeCycleName##_##Name) \
817 void OwnerClass::_ZFP_propL_##lifeCycleName##_##Name( \
818 ZF_IN zfself::_ZFP_PropHT_##Name constFix(const) &propertyValue \
819 , ZF_IN zfself::_ZFP_PropHT_##Name const &propertyValueOld \
820 )
821
822extern ZFLIB_ZFCore void _ZFP_ZFPropertyLifeCycleCall_init_retain(
823 ZF_IN const ZFProperty *property
824 , ZF_IN ZFObject *propertyOwnerObject
825 , ZF_IN ZFObject *value
826 , ZF_IN zfbool notifyOwnerAttach
827 , ZF_IN void (*rawValueStoreCallback)(
828 ZF_IN_OUT void *rawValueStoreToken
829 , ZF_IN ZFObject *value
830 )
831 , ZF_IN void *rawValueStoreToken
832 );
833extern ZFLIB_ZFCore void _ZFP_ZFPropertyLifeCycleCall_init_assign(
834 ZF_IN const ZFProperty *property
835 , ZF_IN ZFObject *propertyOwnerObject
836 , ZF_IN void *value
837 , ZF_IN zfbool notifyOwnerAttach
838 , ZF_IN ZFObject *weakProp
839 );
840extern ZFLIB_ZFCore void _ZFP_ZFPropertyLifeCycleCall_dealloc_retain(
841 ZF_IN const ZFProperty *property
842 , ZF_IN ZFObject *propertyOwnerObject
843 , ZF_IN ZFObject *value
844 , ZF_IN zfbool notifyOwnerDetach
845 );
846extern ZFLIB_ZFCore void _ZFP_ZFPropertyLifeCycleCall_dealloc_assign(
847 ZF_IN const ZFProperty *property
848 , ZF_IN ZFObject *propertyOwnerObject
849 , ZF_IN void *value
850 , ZF_IN zfbool notifyOwnerDetach
851 , ZF_IN ZFObject *weakProp
852 );
853extern ZFLIB_ZFCore void _ZFP_ZFPropertyLifeCycleCall_setter_retain(
854 ZF_IN const ZFProperty *property
855 , ZF_IN ZFObject *propertyOwnerObject
856 , ZF_IN zfbool accessed
857 , ZF_IN ZFObject *propertyValueOld
858 , ZF_IN ZFObject *propertyValueNew
859 , ZF_IN void (*rawValueStoreCallback)(
860 ZF_IN_OUT void *rawValueStoreToken
861 , ZF_IN ZFObject *value
862 )
863 , ZF_IN void *rawValueStoreToken
864 );
865extern ZFLIB_ZFCore void _ZFP_ZFPropertyLifeCycleCall_setter_assign(
866 ZF_IN const ZFProperty *property
867 , ZF_IN ZFObject *propertyOwnerObject
868 , ZF_IN zfbool accessed
869 , ZF_IN void *propertyValueOld
870 , ZF_IN const void *propertyValueNew
871 , ZF_IN void *(*rawValueStoreCallback)(
872 ZF_IN_OUT void *rawValueStoreToken
873 , ZF_IN const void *value
874 )
875 , ZF_IN void *rawValueStoreToken
876 , ZF_IN ZFObject *weakPropOld
877 , ZF_IN ZFObject *weakPropNew
878 );
879
880ZF_NAMESPACE_GLOBAL_END
881#endif // #ifndef _ZFI_ZFPropertyDeclare_h_
882
ZFLIB_ZFCore
#define ZFLIB_ZFCore
used to export symbols
Definition ZFCoreEnvDef.h:30
zfnewPlacement
#define zfnewPlacement(buf, Type,...)
placement new defined for future use, see zfnew for more info
Definition ZFCoreTypeDef_ClassType.h:123
ZF_IN
#define ZF_IN
dummy macro that shows the param used as required input
Definition ZFCoreTypeDef_ClassType.h:198
zfdeletePlacement
#define zfdeletePlacement(instance)
placement delete (instance->~Type()) defined for future use, see zfnew for more info
Definition ZFCoreTypeDef_ClassType.h:127
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
ZF_IN_OUT
#define ZF_IN_OUT
dummy macro that shows the param used as required input and output
Definition ZFCoreTypeDef_ClassType.h:214
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
zfbyte
_ZFT_t_zfbyte zfbyte
8-bit unsigned value, see zfindex
Definition ZFCoreTypeDef_CoreType.h:194
zfuint
_ZFT_t_zfuint zfuint
same as unsigned int, see zfindex
Definition ZFCoreTypeDef_CoreType.h:169
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:148
zfunsafe_zfobjRetain
#define zfunsafe_zfobjRetain(obj)
no lock version of zfobjRetain, use with caution
Definition ZFObjectRetain.h:128
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:63
ZFObject
base class of all objects
Definition ZFObjectCore.h:195
ZFProperty
info for a property for ZFObject, see ZFPROPERTY_RETAIN for more info
Definition ZFProperty.h:27
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