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