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 this->Set(InitValueOrEmpty); \
463 _ZFP_ZFPropertyLifeCycleCall_init_retain( \
464 zfself::_ZFP_Prop_##Name() \
465 , owner \
466 , zfcast(ZFObject *, this->Get()) \
467 , notifyOwnerAttach \
468 , _ZFP_PropRVH<_ZFP_PropVT_##Name>::VS \
469 , this \
470 ); \
471 } \
472 return this->Get(); \
473 } \
474 void Dealloc( \
475 ZF_IN ZFObject *owner \
476 , ZF_IN zfbool notifyOwnerDetach \
477 ) { \
478 if(this->VA()) { \
479 _ZFP_ZFPropertyLifeCycleCall_dealloc_retain( \
480 zfself::_ZFP_Prop_##Name() \
481 , owner \
482 , zfcast(ZFObject *, this->Get()) \
483 , notifyOwnerDetach \
484 ); \
485 this->Reset(); \
486 } \
487 } \
488 }; \
489 zfself::_ZFP_PropV_##Name Name##_PropV; \
490 private: \
491 static zfbool _ZFP_propCbIsInit_##Name( \
492 ZF_IN const ZFProperty *property \
493 , ZF_IN zfany const &ownerObj \
494 , ZF_OUT_OPT zfauto *outInitValue \
495 ) { \
496 zfself *t = zfcastNoExt(zfself *, ownerObj); \
497 if(t && t->Name##_PropV.VA()) { \
498 zfself::_ZFP_PropV_##Name _holder; \
499 if(outInitValue != zfnull) { \
500 *outInitValue = _holder.Init(ownerObj, zffalse); \
501 } \
502 zfbool ret = (ZFObjectCompareValue( \
503 t->Name(), _holder.Init(ownerObj, zffalse)) \
504 == ZFCompareEqual); \
505 _holder.Dealloc(ownerObj, zffalse); \
506 return ret; \
507 } \
508 else { \
509 return zftrue; \
510 } \
511 } \
512 public:
513#define _ZFP_ZFPROPERTY_VALUE_DECLARE_ASSIGN(Type, ZFTypeId_noneOrType, Name, \
514 InitValueOrEmpty) \
515 public: \
516 \
517 typedef Type _ZFP_PropVT_##Name; \
518 typedef Type _ZFP_PropHT_##Name; \
519 \
520 private: \
521 zffinal zfclassNotPOD _ZFP_PropV_##Name : zfextend _ZFP_PropAVH<_ZFP_PropVT_##Name> { \
522 public: \
523 _ZFP_PropV_##Name(void) \
524 { \
525 zfself::_ZFP_Prop_##Name(); \
526 } \
527 public: \
528 zfself::_ZFP_PropVT_##Name &Init( \
529 ZF_IN ZFObject *owner \
530 , ZF_IN zfbool notifyOwnerAttach \
531 ) { \
532 if(!this->VA()) { \
533 this->Set(InitValueOrEmpty); \
534 _ZFP_ZFPropertyLifeCycleCall_init_assign( \
535 zfself::_ZFP_Prop_##Name() \
536 , owner \
537 , &(this->Get()) \
538 , notifyOwnerAttach \
539 , _ZFP_PropWeak<zfself::_ZFP_PropVT_##Name>::v(this->Get()) \
540 ); \
541 } \
542 return this->Get(); \
543 } \
544 void Dealloc( \
545 ZF_IN ZFObject *owner \
546 , ZF_IN zfbool notifyOwnerDetach \
547 ) { \
548 if(this->VA()) { \
549 _ZFP_ZFPropertyLifeCycleCall_dealloc_assign( \
550 zfself::_ZFP_Prop_##Name() \
551 , owner \
552 , &(this->Get()) \
553 , notifyOwnerDetach \
554 , _ZFP_PropWeak<zfself::_ZFP_PropVT_##Name>::v(this->Get()) \
555 ); \
556 this->Reset(); \
557 } \
558 } \
559 }; \
560 zfself::_ZFP_PropV_##Name Name##_PropV; \
561 private: \
562 static zfbool _ZFP_propCbIsInit_##Name( \
563 ZF_IN const ZFProperty *property \
564 , ZF_IN zfany const &ownerObj \
565 , ZF_OUT_OPT zfauto *outInitValue \
566 ) { \
567 zfself *t = zfcastNoExt(zfself *, ownerObj); \
568 if(t && t->Name##_PropV.VA()) { \
569 zfself::_ZFP_PropV_##Name _holder; \
570 if(outInitValue != zfnull) { \
571 ZFTypeId<zfself::_ZFP_PropVT_##Name>::ValueStore(*outInitValue, _holder.Init(ownerObj, zffalse)); \
572 } \
573 zfbool ret = (ZFComparerDefault( \
574 t->Name(), _holder.Init(ownerObj, zffalse)) \
575 == ZFCompareEqual); \
576 _holder.Dealloc(ownerObj, zffalse); \
577 return ret; \
578 } \
579 else { \
580 return zftrue; \
581 } \
582 } \
583 public:
584
585// ============================================================
586#define _ZFP_ZFPROPERTY_DECLARE_CALLBACK(Type, Name) \
587 private: \
588 static zfbool _ZFP_propCbAccessed_##Name( \
589 ZF_IN const ZFProperty *property \
590 , ZF_IN zfany const &ownerObj \
591 ) { \
592 zfself *t = zfcastNoExt(zfself *, ownerObj); \
593 return t && t->Name##_PropV.VA(); \
594 } \
595 static void _ZFP_propCbReset_##Name( \
596 ZF_IN const ZFProperty *property \
597 , ZF_IN zfany const &owner \
598 ) { \
599 if(_ZFP_propCbAccessed_##Name(property, owner)) { \
600 owner->_ZFP_ZFObject_objectPropertyValueOnReset(zfself::_ZFP_Prop_##Name()); \
601 zfcast(zfself *, owner)->Name##_PropV.Dealloc(owner, zftrue); \
602 } \
603 } \
604 static void _ZFP_propCbEnsureInit_##Name( \
605 ZF_IN const ZFProperty *property \
606 , ZF_IN zfany const &owner \
607 ) { \
608 zfcast(zfself *, owner)->Name##_PropV.Init(owner, zftrue); \
609 } \
610 static void _ZFP_propCbDel_##Name( \
611 ZF_IN const ZFProperty *property \
612 , ZF_IN zfany const &owner \
613 ) { \
614 zfself *t = zfcastNoExt(zfself *, owner); \
615 if(t) { \
616 t->Name##_PropV.Dealloc(owner, zffalse); \
617 } \
618 } \
619 public:
620
621// ============================================================
622#define _ZFP_ZFPROPERTY_DECLARE_RETAIN(Type, ZFTypeId_noneOrType, Name, InitValueOrEmpty) \
623 _ZFP_ZFPROPERTY_DECLARE_REGISTER_RETAIN(Type, ZFTypeId_noneOrType, Name, zftTraits<Type>::TrType::ClassData()) \
624 _ZFP_ZFPROPERTY_VALUE_DECLARE_RETAIN(Type, ZFTypeId_noneOrType, Name, InitValueOrEmpty) \
625 _ZFP_ZFPROPERTY_DECLARE_CALLBACK(Type, Name)
626#define _ZFP_ZFPROPERTY_DECLARE_ASSIGN(Type, ZFTypeId_noneOrType, Name, InitValueOrEmpty) \
627 _ZFP_ZFPROPERTY_DECLARE_REGISTER_ASSIGN(Type, ZFTypeId_noneOrType, Name, zfnull) \
628 _ZFP_ZFPROPERTY_VALUE_DECLARE_ASSIGN(Type, ZFTypeId_noneOrType, Name, InitValueOrEmpty) \
629 _ZFP_ZFPROPERTY_DECLARE_CALLBACK(Type, Name)
630
631// ============================================================
632#define _ZFP_ZFPROPERTY_SETTER_RETAIN(AccessType, Type, Name) \
633 AccessType: \
634 _ZFP_ZFMETHOD_INLINE( \
635 notAutoRegister \
636 , AccessType, ZFMethodTypeVirtual, S \
637 , void, Name \
638 , _ZFP_mP_EXPAND(ZFMP_IN(Type const &, propertyValue)) \
639 , _ZFP_ZFMP_DUMMY() \
640 , _ZFP_ZFMP_DUMMY() \
641 , _ZFP_ZFMP_DUMMY() \
642 , _ZFP_ZFMP_DUMMY() \
643 , _ZFP_ZFMP_DUMMY() \
644 , _ZFP_ZFMP_DUMMY() \
645 , _ZFP_ZFMP_DUMMY() \
646 ) { \
647 ZFObjectLock(this); \
648 zfbool accessed = Name##_PropV.VA(); \
649 ZFObject *valueOld = zfcast(ZFObject *, Name##_PropV.Init(this->toObject(), zffalse)); \
650 _ZFP_ZFPropertyLifeCycleCall_setter_retain( \
651 zfself::_ZFP_Prop_##Name() \
652 , this->toObject() \
653 , accessed \
654 , valueOld \
655 , zfcast(ZFObject *, propertyValue) \
656 , _ZFP_PropRVH<zfself::_ZFP_PropVT_##Name>::VS \
657 , &Name##_PropV \
658 ); \
659 ZFObjectUnlock(this); \
660 } \
661 public:
662#define _ZFP_ZFPROPERTY_SETTER_ASSIGN(AccessType, Type, Name) \
663 AccessType: \
664 _ZFP_ZFMETHOD_INLINE( \
665 notAutoRegister \
666 , AccessType, ZFMethodTypeVirtual, S \
667 , void, Name \
668 , _ZFP_mP_EXPAND(ZFMP_IN(Type const &, propertyValue)) \
669 , _ZFP_ZFMP_DUMMY() \
670 , _ZFP_ZFMP_DUMMY() \
671 , _ZFP_ZFMP_DUMMY() \
672 , _ZFP_ZFMP_DUMMY() \
673 , _ZFP_ZFMP_DUMMY() \
674 , _ZFP_ZFMP_DUMMY() \
675 , _ZFP_ZFMP_DUMMY() \
676 ) { \
677 ZFObjectLock(this); \
678 zfbool accessed = Name##_PropV.VA(); \
679 Type valueOld = Name##_PropV.Init(this->toObject(), zffalse); \
680 _ZFP_ZFPropertyLifeCycleCall_setter_assign( \
681 zfself::_ZFP_Prop_##Name() \
682 , this->toObject() \
683 , accessed \
684 , &valueOld \
685 , &propertyValue \
686 , _ZFP_PropAVH<zfself::_ZFP_PropVT_##Name>::VS \
687 , &Name##_PropV \
688 , _ZFP_PropWeak<zfself::_ZFP_PropVT_##Name>::v(valueOld) \
689 , _ZFP_PropWeak<zfself::_ZFP_PropVT_##Name>::v(propertyValue) \
690 ); \
691 ZFObjectUnlock(this); \
692 } \
693 public:
694#define _ZFP_ZFPROPERTY_GETTER_RETAIN(AccessType, Type, Name) \
695 AccessType: \
696 _ZFP_ZFMETHOD_INLINE( \
697 notAutoRegister \
698 , AccessType, ZFMethodTypeVirtual, G \
699 , Type const &, Name \
700 , _ZFP_ZFMP_DUMMY() \
701 , _ZFP_ZFMP_DUMMY() \
702 , _ZFP_ZFMP_DUMMY() \
703 , _ZFP_ZFMP_DUMMY() \
704 , _ZFP_ZFMP_DUMMY() \
705 , _ZFP_ZFMP_DUMMY() \
706 , _ZFP_ZFMP_DUMMY() \
707 , _ZFP_ZFMP_DUMMY() \
708 ) { \
709 ZFObjectLocker(this); \
710 return Name##_PropV.Init(this->toObject(), zftrue); \
711 } \
712 public:
713#define _ZFP_ZFPROPERTY_GETTER_ASSIGN(AccessType, Type, Name) \
714 AccessType: \
715 _ZFP_ZFMETHOD_INLINE( \
716 notAutoRegister \
717 , AccessType, ZFMethodTypeVirtual, G \
718 /* ZFTAG_TRICKS: return non const ref, but use const ref in reflection */ \
719 , Type &, Name \
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 , _ZFP_ZFMP_DUMMY() \
727 , _ZFP_ZFMP_DUMMY() \
728 ) { \
729 ZFObjectLocker(this); \
730 return Name##_PropV.Init(this->toObject(), zftrue); \
731 } \
732 public:
733
734// ============================================================
735#define _ZFP_ZFPROPERTY_LIFE_CYCLE_OVERRIDE_INLINE(Type, Name, lifeCycleName, constFix, extraRegStep) \
736 private: \
737 zfclassNotPOD _ZFP_propLReg_##lifeCycleName##_##Name { \
738 public: \
739 _ZFP_propLReg_##lifeCycleName##_##Name(void) { \
740 static zfbool needInit = zftrue; \
741 if(needInit) { \
742 needInit = zffalse; \
743 zfself::_ZFP_Prop_##Name()->_ZFP_ZFPropertyLifeCycleRegister( \
744 ZFPropertyLifeCycle##lifeCycleName \
745 , zfself::ClassData() \
746 , zfself::_ZFP_propLI_##lifeCycleName##_##Name \
747 , zfnull \
748 ); \
749 extraRegStep \
750 } \
751 } \
752 }; \
753 _ZFP_propLReg_##lifeCycleName##_##Name _ZFP_propLReg_##lifeCycleName##_##Name; \
754 static void _ZFP_propLI_##lifeCycleName##_##Name( \
755 ZF_IN ZFObject *propertyOwnerObject \
756 , ZF_IN const ZFProperty *property \
757 , ZF_IN void *propertyValue \
758 , ZF_IN const void *propertyValueOld \
759 , ZF_IN ZFObject *propertyLifeCycleUserData \
760 ) { \
761 zfcast(zfself *, propertyOwnerObject)->zfself::_ZFP_propL_##lifeCycleName##_##Name( \
762 *(constFix(const) zfself::_ZFP_PropHT_##Name *)propertyValue \
763 , *(zfself::_ZFP_PropHT_##Name *)propertyValueOld \
764 ); \
765 } \
766 public: \
767 zffinal void _ZFP_propL_##lifeCycleName##_##Name( \
768 ZF_IN zfself::_ZFP_PropHT_##Name constFix(const) &propertyValue \
769 , ZF_IN zfself::_ZFP_PropHT_##Name const &propertyValueOld \
770 )
771#define _ZFP_ZFPROPERTY_LIFE_CYCLE_OVERRIDE_DECLARE(Type, Name, lifeCycleName, constFix) \
772 public: \
773 zffinal void _ZFP_propL_##lifeCycleName##_##Name( \
774 ZF_IN zfself::_ZFP_PropHT_##Name constFix(const) &propertyValue \
775 , ZF_IN zfself::_ZFP_PropHT_##Name const &propertyValueOld \
776 );
777#define _ZFP_ZFPROPERTY_LIFE_CYCLE_OVERRIDE_DEFINE(OwnerClass, Type, Name, lifeCycleName, constFix, extraRegStep) \
778 ZF_STATIC_REGISTER_INIT(propL_##OwnerClass##_##lifeCycleName##_##Name) { \
779 OwnerClass::_ZFP_Prop_##Name()->_ZFP_ZFPropertyLifeCycleRegister( \
780 ZFPropertyLifeCycle##lifeCycleName \
781 , OwnerClass::ClassData() \
782 , a \
783 , zfnull \
784 ); \
785 extraRegStep \
786 } \
787 public: \
788 static void a( \
789 ZF_IN ZFObject *propertyOwnerObject \
790 , ZF_IN const ZFProperty *property \
791 , ZF_IN void *propertyValue \
792 , ZF_IN const void *propertyValueOld \
793 , ZF_IN ZFObject *propertyLifeCycleUserData \
794 ) { \
795 zfcast(OwnerClass *, propertyOwnerObject)->OwnerClass::_ZFP_propL_##lifeCycleName##_##Name( \
796 *(constFix(const) OwnerClass::_ZFP_PropHT_##Name *)propertyValue \
797 , *(OwnerClass::_ZFP_PropHT_##Name *)propertyValueOld \
798 ); \
799 } \
800 ZF_STATIC_REGISTER_END(propL_##OwnerClass##_##lifeCycleName##_##Name) \
801 void OwnerClass::_ZFP_propL_##lifeCycleName##_##Name( \
802 ZF_IN zfself::_ZFP_PropHT_##Name constFix(const) &propertyValue \
803 , ZF_IN zfself::_ZFP_PropHT_##Name const &propertyValueOld \
804 )
805
806extern ZFLIB_ZFCore void _ZFP_ZFPropertyLifeCycleCall_init_retain(
807 ZF_IN const ZFProperty *property
808 , ZF_IN ZFObject *propertyOwnerObject
809 , ZF_IN ZFObject *value
810 , ZF_IN zfbool notifyOwnerAttach
811 , ZF_IN void (*rawValueStoreCallback)(
812 ZF_IN_OUT void *rawValueStoreToken
813 , ZF_IN ZFObject *value
814 )
815 , ZF_IN void *rawValueStoreToken
816 );
817extern ZFLIB_ZFCore void _ZFP_ZFPropertyLifeCycleCall_init_assign(
818 ZF_IN const ZFProperty *property
819 , ZF_IN ZFObject *propertyOwnerObject
820 , ZF_IN void *value
821 , ZF_IN zfbool notifyOwnerAttach
822 , ZF_IN ZFObject *weakProp
823 );
824extern ZFLIB_ZFCore void _ZFP_ZFPropertyLifeCycleCall_dealloc_retain(
825 ZF_IN const ZFProperty *property
826 , ZF_IN ZFObject *propertyOwnerObject
827 , ZF_IN ZFObject *value
828 , ZF_IN zfbool notifyOwnerDetach
829 );
830extern ZFLIB_ZFCore void _ZFP_ZFPropertyLifeCycleCall_dealloc_assign(
831 ZF_IN const ZFProperty *property
832 , ZF_IN ZFObject *propertyOwnerObject
833 , ZF_IN void *value
834 , ZF_IN zfbool notifyOwnerDetach
835 , ZF_IN ZFObject *weakProp
836 );
837extern ZFLIB_ZFCore void _ZFP_ZFPropertyLifeCycleCall_setter_retain(
838 ZF_IN const ZFProperty *property
839 , ZF_IN ZFObject *propertyOwnerObject
840 , ZF_IN zfbool accessed
841 , ZF_IN ZFObject *propertyValueOld
842 , ZF_IN ZFObject *propertyValueNew
843 , ZF_IN void (*rawValueStoreCallback)(
844 ZF_IN_OUT void *rawValueStoreToken
845 , ZF_IN ZFObject *value
846 )
847 , ZF_IN void *rawValueStoreToken
848 );
849extern ZFLIB_ZFCore void _ZFP_ZFPropertyLifeCycleCall_setter_assign(
850 ZF_IN const ZFProperty *property
851 , ZF_IN ZFObject *propertyOwnerObject
852 , ZF_IN zfbool accessed
853 , ZF_IN void *propertyValueOld
854 , ZF_IN const void *propertyValueNew
855 , ZF_IN void *(*rawValueStoreCallback)(
856 ZF_IN_OUT void *rawValueStoreToken
857 , ZF_IN const void *value
858 )
859 , ZF_IN void *rawValueStoreToken
860 , ZF_IN ZFObject *weakPropOld
861 , ZF_IN ZFObject *weakPropNew
862 );
863
864ZF_NAMESPACE_GLOBAL_END
865#endif // #ifndef _ZFI_ZFPropertyDeclare_h_
866
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