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 , zfnull \
394 , zfself::ClassData() \
395 , zftext(#Name) \
396 , zftext(#Type) \
397 , ZFTypeId_noneOrType \
398 , ZFMethodAccessDetail_1(zfself, Name \
399 , ZFMP_IN(Type const &, propertyValue) \
400 ) \
401 , ZFMethodAccessDetail_0(zfself, Name) \
402 , propertyClassOfRetainProperty \
403 , zfself::_ZFP_propCbAccessed_##Name \
404 , zfself::_ZFP_propCbIsInit_##Name \
405 , zfself::_ZFP_propCbReset_##Name \
406 , zfnull \
407 , zfnull \
408 , zfself::_ZFP_propCbEnsureInit_##Name \
409 , zfself::_ZFP_propCbDel_##Name \
410 ); \
411 return _propertyInfoHolder.propertyInfo; \
412 }
413#define _ZFP_ZFPROPERTY_DECLARE_REGISTER_ASSIGN(Type, ZFTypeId_noneOrType, Name, propertyClassOfRetainProperty) \
414 public: \
415 static ZFProperty *_ZFP_Prop_##Name(void) { \
416 static _ZFP_ZFPropertyRegisterHolder _propertyInfoHolder(zffalse \
417 , zffalse \
418 , zfnull \
419 , zfself::ClassData() \
420 , zftext(#Name) \
421 , zftext(#Type) \
422 , ZFTypeId_noneOrType \
423 , ZFMethodAccessDetail_1(zfself, Name \
424 , ZFMP_IN(Type const &, propertyValue) \
425 ) \
426 , ZFMethodAccessDetail_0(zfself, Name) \
427 , propertyClassOfRetainProperty \
428 , zfself::_ZFP_propCbAccessed_##Name \
429 , zfself::_ZFP_propCbIsInit_##Name \
430 , zfself::_ZFP_propCbReset_##Name \
431 , zfnull \
432 , zfnull \
433 , zfself::_ZFP_propCbEnsureInit_##Name \
434 , zfself::_ZFP_propCbDel_##Name \
435 ); \
436 return _propertyInfoHolder.propertyInfo; \
437 }
438
439#define _ZFP_ZFPROPERTY_VALUE_DECLARE_RETAIN(Type, ZFTypeId_noneOrType, Name, InitValueOrEmpty) \
440 public: \
441 \
442 typedef Type _ZFP_PropVT_##Name; \
443 typedef zfauto _ZFP_PropHT_##Name; \
444 \
445 private: \
446 zffinal zfclassNotPOD _ZFP_PropV_##Name : zfextend _ZFP_PropRVH<_ZFP_PropVT_##Name> { \
447 public: \
448 _ZFP_PropV_##Name(void) \
449 { \
450 zfself::_ZFP_Prop_##Name(); \
451 } \
452 public: \
453 zfself::_ZFP_PropVT_##Name &Init( \
454 ZF_IN ZFObject *owner \
455 , ZF_IN zfbool notifyOwnerAttach \
456 ) { \
457 if(!this->VA()) { \
458 this->Set(InitValueOrEmpty); \
459 _ZFP_ZFPropertyLifeCycleCall_init_retain( \
460 zfself::_ZFP_Prop_##Name() \
461 , owner \
462 , zfcast(ZFObject *, this->Get()) \
463 , notifyOwnerAttach \
464 , _ZFP_PropRVH<_ZFP_PropVT_##Name>::VS \
465 , this \
466 ); \
467 } \
468 return this->Get(); \
469 } \
470 void Dealloc( \
471 ZF_IN ZFObject *owner \
472 , ZF_IN zfbool notifyOwnerDetach \
473 ) { \
474 if(this->VA()) { \
475 _ZFP_ZFPropertyLifeCycleCall_dealloc_retain( \
476 zfself::_ZFP_Prop_##Name() \
477 , owner \
478 , zfcast(ZFObject *, this->Get()) \
479 , notifyOwnerDetach \
480 ); \
481 this->Reset(); \
482 } \
483 } \
484 }; \
485 zfself::_ZFP_PropV_##Name Name##_PropV; \
486 private: \
487 static zfbool _ZFP_propCbIsInit_##Name( \
488 ZF_IN const ZFProperty *property \
489 , ZF_IN zfany const &ownerObj \
490 , ZF_OUT_OPT zfauto *outInitValue \
491 ) { \
492 zfself *t = zfcast(zfself *, ownerObj); \
493 if(t->Name##_PropV.VA()) { \
494 zfself::_ZFP_PropV_##Name _holder; \
495 if(outInitValue != zfnull) { \
496 *outInitValue = _holder.Init(ownerObj, zffalse); \
497 } \
498 zfbool ret = (ZFObjectCompareValue( \
499 t->Name(), _holder.Init(ownerObj, zffalse)) \
500 == ZFCompareEqual); \
501 _holder.Dealloc(ownerObj, zffalse); \
502 return ret; \
503 } \
504 else { \
505 return zftrue; \
506 } \
507 } \
508 public:
509#define _ZFP_ZFPROPERTY_VALUE_DECLARE_ASSIGN(Type, ZFTypeId_noneOrType, Name, \
510 InitValueOrEmpty) \
511 public: \
512 \
513 typedef Type _ZFP_PropVT_##Name; \
514 typedef Type _ZFP_PropHT_##Name; \
515 \
516 private: \
517 zffinal zfclassNotPOD _ZFP_PropV_##Name : zfextend _ZFP_PropAVH<_ZFP_PropVT_##Name> { \
518 public: \
519 _ZFP_PropV_##Name(void) \
520 { \
521 zfself::_ZFP_Prop_##Name(); \
522 } \
523 public: \
524 zfself::_ZFP_PropVT_##Name &Init( \
525 ZF_IN ZFObject *owner \
526 , ZF_IN zfbool notifyOwnerAttach \
527 ) { \
528 if(!this->VA()) { \
529 this->Set(InitValueOrEmpty); \
530 _ZFP_ZFPropertyLifeCycleCall_init_assign( \
531 zfself::_ZFP_Prop_##Name() \
532 , owner \
533 , &(this->Get()) \
534 , notifyOwnerAttach \
535 , _ZFP_PropWeak<zfself::_ZFP_PropVT_##Name>::v(this->Get()) \
536 ); \
537 } \
538 return this->Get(); \
539 } \
540 void Dealloc( \
541 ZF_IN ZFObject *owner \
542 , ZF_IN zfbool notifyOwnerDetach \
543 ) { \
544 if(this->VA()) { \
545 _ZFP_ZFPropertyLifeCycleCall_dealloc_assign( \
546 zfself::_ZFP_Prop_##Name() \
547 , owner \
548 , &(this->Get()) \
549 , notifyOwnerDetach \
550 , _ZFP_PropWeak<zfself::_ZFP_PropVT_##Name>::v(this->Get()) \
551 ); \
552 this->Reset(); \
553 } \
554 } \
555 }; \
556 zfself::_ZFP_PropV_##Name Name##_PropV; \
557 private: \
558 static zfbool _ZFP_propCbIsInit_##Name( \
559 ZF_IN const ZFProperty *property \
560 , ZF_IN zfany const &ownerObj \
561 , ZF_OUT_OPT zfauto *outInitValue \
562 ) { \
563 zfself *t = zfcast(zfself *, ownerObj); \
564 if(t->Name##_PropV.VA()) { \
565 zfself::_ZFP_PropV_##Name _holder; \
566 if(outInitValue != zfnull) { \
567 ZFTypeId<zfself::_ZFP_PropVT_##Name>::ValueStore(*outInitValue, _holder.Init(ownerObj, zffalse)); \
568 } \
569 zfbool ret = (ZFComparerDefault( \
570 t->Name(), _holder.Init(ownerObj, zffalse)) \
571 == ZFCompareEqual); \
572 _holder.Dealloc(ownerObj, zffalse); \
573 return ret; \
574 } \
575 else { \
576 return zftrue; \
577 } \
578 } \
579 public:
580
581// ============================================================
582#define _ZFP_ZFPROPERTY_DECLARE_CALLBACK(Type, Name) \
583 private: \
584 static zfbool _ZFP_propCbAccessed_##Name( \
585 ZF_IN const ZFProperty *property \
586 , ZF_IN zfany const &ownerObj \
587 ) { \
588 return zfcast(zfself *, ownerObj)->Name##_PropV.VA(); \
589 } \
590 static void _ZFP_propCbReset_##Name( \
591 ZF_IN const ZFProperty *property \
592 , ZF_IN zfany const &owner \
593 ) { \
594 if(_ZFP_propCbAccessed_##Name(property, owner)) { \
595 owner->_ZFP_ZFObject_objectPropertyValueOnReset(zfself::_ZFP_Prop_##Name()); \
596 } \
597 zfcast(zfself *, owner)->Name##_PropV.Dealloc(owner, zftrue); \
598 } \
599 static void _ZFP_propCbEnsureInit_##Name( \
600 ZF_IN const ZFProperty *property \
601 , ZF_IN zfany const &owner \
602 ) { \
603 zfcast(zfself *, owner)->Name##_PropV.Init(owner, zftrue); \
604 } \
605 static void _ZFP_propCbDel_##Name( \
606 ZF_IN const ZFProperty *property \
607 , ZF_IN zfany const &owner \
608 ) { \
609 zfcast(zfself *, owner)->Name##_PropV.Dealloc(owner, zffalse); \
610 } \
611 public:
612
613// ============================================================
614#define _ZFP_ZFPROPERTY_DECLARE_RETAIN(Type, ZFTypeId_noneOrType, Name, InitValueOrEmpty) \
615 _ZFP_ZFPROPERTY_DECLARE_REGISTER_RETAIN(Type, ZFTypeId_noneOrType, Name, zftTraits<Type>::TrType::ClassData()) \
616 _ZFP_ZFPROPERTY_VALUE_DECLARE_RETAIN(Type, ZFTypeId_noneOrType, Name, InitValueOrEmpty) \
617 _ZFP_ZFPROPERTY_DECLARE_CALLBACK(Type, Name)
618#define _ZFP_ZFPROPERTY_DECLARE_ASSIGN(Type, ZFTypeId_noneOrType, Name, InitValueOrEmpty) \
619 _ZFP_ZFPROPERTY_DECLARE_REGISTER_ASSIGN(Type, ZFTypeId_noneOrType, Name, zfnull) \
620 _ZFP_ZFPROPERTY_VALUE_DECLARE_ASSIGN(Type, ZFTypeId_noneOrType, Name, InitValueOrEmpty) \
621 _ZFP_ZFPROPERTY_DECLARE_CALLBACK(Type, Name)
622
623// ============================================================
624#define _ZFP_ZFPROPERTY_SETTER_RETAIN(AccessType, Type, Name) \
625 AccessType: \
626 _ZFP_ZFMETHOD_INLINE( \
627 notAutoRegister \
628 , AccessType, ZFMethodTypeVirtual, S \
629 , void, Name \
630 , _ZFP_mP_EXPAND(ZFMP_IN(Type const &, propertyValue)) \
631 , _ZFP_ZFMP_DUMMY() \
632 , _ZFP_ZFMP_DUMMY() \
633 , _ZFP_ZFMP_DUMMY() \
634 , _ZFP_ZFMP_DUMMY() \
635 , _ZFP_ZFMP_DUMMY() \
636 , _ZFP_ZFMP_DUMMY() \
637 , _ZFP_ZFMP_DUMMY() \
638 ) { \
639 ZFObjectLock(this); \
640 zfbool accessed = Name##_PropV.VA(); \
641 ZFObject *valueOld = zfcast(ZFObject *, Name##_PropV.Init(this->toObject(), zffalse)); \
642 _ZFP_ZFPropertyLifeCycleCall_setter_retain( \
643 zfself::_ZFP_Prop_##Name() \
644 , this->toObject() \
645 , accessed \
646 , valueOld \
647 , zfcast(ZFObject *, propertyValue) \
648 , _ZFP_PropRVH<zfself::_ZFP_PropVT_##Name>::VS \
649 , &Name##_PropV \
650 ); \
651 ZFObjectUnlock(this); \
652 } \
653 public:
654#define _ZFP_ZFPROPERTY_SETTER_ASSIGN(AccessType, Type, Name) \
655 AccessType: \
656 _ZFP_ZFMETHOD_INLINE( \
657 notAutoRegister \
658 , AccessType, ZFMethodTypeVirtual, S \
659 , void, Name \
660 , _ZFP_mP_EXPAND(ZFMP_IN(Type const &, propertyValue)) \
661 , _ZFP_ZFMP_DUMMY() \
662 , _ZFP_ZFMP_DUMMY() \
663 , _ZFP_ZFMP_DUMMY() \
664 , _ZFP_ZFMP_DUMMY() \
665 , _ZFP_ZFMP_DUMMY() \
666 , _ZFP_ZFMP_DUMMY() \
667 , _ZFP_ZFMP_DUMMY() \
668 ) { \
669 ZFObjectLock(this); \
670 zfbool accessed = Name##_PropV.VA(); \
671 Type valueOld = Name##_PropV.Init(this->toObject(), zffalse); \
672 _ZFP_ZFPropertyLifeCycleCall_setter_assign( \
673 zfself::_ZFP_Prop_##Name() \
674 , this->toObject() \
675 , accessed \
676 , &valueOld \
677 , &propertyValue \
678 , _ZFP_PropAVH<zfself::_ZFP_PropVT_##Name>::VS \
679 , &Name##_PropV \
680 , _ZFP_PropWeak<zfself::_ZFP_PropVT_##Name>::v(valueOld) \
681 , _ZFP_PropWeak<zfself::_ZFP_PropVT_##Name>::v(propertyValue) \
682 ); \
683 ZFObjectUnlock(this); \
684 } \
685 public:
686#define _ZFP_ZFPROPERTY_GETTER_RETAIN(AccessType, Type, Name) \
687 AccessType: \
688 _ZFP_ZFMETHOD_INLINE( \
689 notAutoRegister \
690 , AccessType, ZFMethodTypeVirtual, G \
691 , Type const &, 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.Init(this->toObject(), zftrue); \
703 } \
704 public:
705#define _ZFP_ZFPROPERTY_GETTER_ASSIGN(AccessType, Type, Name) \
706 AccessType: \
707 _ZFP_ZFMETHOD_INLINE( \
708 notAutoRegister \
709 , AccessType, ZFMethodTypeVirtual, G \
710 /* ZFTAG_TRICKS: return non const ref, but use const ref in reflection */ \
711 , Type &, 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 ZFObjectLocker(this); \
722 return Name##_PropV.Init(this->toObject(), zftrue); \
723 } \
724 public:
725
726// ============================================================
727#define _ZFP_ZFPROPERTY_LIFE_CYCLE_OVERRIDE_INLINE(Type, Name, lifeCycleName, constFix, extraRegStep) \
728 private: \
729 zfclassNotPOD _ZFP_propLReg_##lifeCycleName##_##Name { \
730 public: \
731 _ZFP_propLReg_##lifeCycleName##_##Name(void) { \
732 static zfbool needInit = zftrue; \
733 if(needInit) { \
734 needInit = zffalse; \
735 _ZFP_ZFPropertyLifeCycleRegister( \
736 zftext(#lifeCycleName) \
737 , zfself::_ZFP_Prop_##Name() \
738 , zfself::ClassData() \
739 , zfself::_ZFP_propLI_##lifeCycleName##_##Name \
740 ); \
741 extraRegStep \
742 } \
743 } \
744 }; \
745 _ZFP_propLReg_##lifeCycleName##_##Name _ZFP_propLReg_##lifeCycleName##_##Name; \
746 static void _ZFP_propLI_##lifeCycleName##_##Name( \
747 ZF_IN ZFObject *propertyOwnerObject \
748 , ZF_IN const ZFProperty *property \
749 , ZF_IN void *propertyValue \
750 , ZF_IN const void *propertyValueOld \
751 , ZF_IN ZFObject *propertyLifeCycleUserData \
752 ) { \
753 zfcast(zfself *, propertyOwnerObject)->zfself::_ZFP_propL_##lifeCycleName##_##Name( \
754 *(constFix(const) zfself::_ZFP_PropHT_##Name *)propertyValue \
755 , *(zfself::_ZFP_PropHT_##Name *)propertyValueOld \
756 ); \
757 } \
758 public: \
759 zffinal void _ZFP_propL_##lifeCycleName##_##Name( \
760 ZF_IN zfself::_ZFP_PropHT_##Name constFix(const) &propertyValue \
761 , ZF_IN zfself::_ZFP_PropHT_##Name const &propertyValueOld \
762 )
763#define _ZFP_ZFPROPERTY_LIFE_CYCLE_OVERRIDE_DECLARE(Type, Name, lifeCycleName, constFix) \
764 public: \
765 zffinal void _ZFP_propL_##lifeCycleName##_##Name( \
766 ZF_IN zfself::_ZFP_PropHT_##Name constFix(const) &propertyValue \
767 , ZF_IN zfself::_ZFP_PropHT_##Name const &propertyValueOld \
768 );
769#define _ZFP_ZFPROPERTY_LIFE_CYCLE_OVERRIDE_DEFINE(OwnerClass, Type, Name, lifeCycleName, constFix, extraRegStep) \
770 ZF_STATIC_REGISTER_INIT(propL_##OwnerClass##_##lifeCycleName##_##Name) { \
771 _ZFP_ZFPropertyLifeCycleRegister( \
772 zftext(#lifeCycleName) \
773 , OwnerClass::_ZFP_Prop_##Name() \
774 , OwnerClass::ClassData() \
775 , a \
776 ); \
777 extraRegStep \
778 } \
779 public: \
780 static void a( \
781 ZF_IN ZFObject *propertyOwnerObject \
782 , ZF_IN const ZFProperty *property \
783 , ZF_IN void *propertyValue \
784 , ZF_IN const void *propertyValueOld \
785 , ZF_IN ZFObject *propertyLifeCycleUserData \
786 ) { \
787 zfcast(OwnerClass *, propertyOwnerObject)->OwnerClass::_ZFP_propL_##lifeCycleName##_##Name( \
788 *(constFix(const) OwnerClass::_ZFP_PropHT_##Name *)propertyValue \
789 , *(OwnerClass::_ZFP_PropHT_##Name *)propertyValueOld \
790 ); \
791 } \
792 ZF_STATIC_REGISTER_END(propL_##OwnerClass##_##lifeCycleName##_##Name) \
793 void OwnerClass::_ZFP_propL_##lifeCycleName##_##Name( \
794 ZF_IN zfself::_ZFP_PropHT_##Name constFix(const) &propertyValue \
795 , ZF_IN zfself::_ZFP_PropHT_##Name const &propertyValueOld \
796 )
797
798extern ZFLIB_ZFCore void _ZFP_ZFPropertyLifeCycleRegister(
799 ZF_IN const zfchar *lifeCycleName
800 , ZF_IN const ZFProperty *property
801 , ZF_IN const ZFClass *ownerClass
802 , ZF_IN _ZFP_PropLifeCycleWrapper propertyLifeCycleWrapper
803 );
804extern ZFLIB_ZFCore void _ZFP_ZFPropertyLifeCycleUnregister(
805 ZF_IN const zfchar *lifeCycleName
806 , ZF_IN const ZFProperty *property
807 , ZF_IN const ZFClass *ownerClass
808 );
809extern ZFLIB_ZFCore void _ZFP_ZFPropertyLifeCycleCall_init_retain(
810 ZF_IN const ZFProperty *property
811 , ZF_IN ZFObject *propertyOwnerObject
812 , ZF_IN ZFObject *value
813 , ZF_IN zfbool notifyOwnerAttach
814 , ZF_IN void (*rawValueStoreCallback)(
815 ZF_IN_OUT void *rawValueStoreToken
816 , ZF_IN ZFObject *value
817 )
818 , ZF_IN void *rawValueStoreToken
819 );
820extern ZFLIB_ZFCore void _ZFP_ZFPropertyLifeCycleCall_init_assign(
821 ZF_IN const ZFProperty *property
822 , ZF_IN ZFObject *propertyOwnerObject
823 , ZF_IN void *value
824 , ZF_IN zfbool notifyOwnerAttach
825 , ZF_IN ZFObject *weakProp
826 );
827extern ZFLIB_ZFCore void _ZFP_ZFPropertyLifeCycleCall_dealloc_retain(
828 ZF_IN const ZFProperty *property
829 , ZF_IN ZFObject *propertyOwnerObject
830 , ZF_IN ZFObject *value
831 , ZF_IN zfbool notifyOwnerDetach
832 );
833extern ZFLIB_ZFCore void _ZFP_ZFPropertyLifeCycleCall_dealloc_assign(
834 ZF_IN const ZFProperty *property
835 , ZF_IN ZFObject *propertyOwnerObject
836 , ZF_IN void *value
837 , ZF_IN zfbool notifyOwnerDetach
838 , ZF_IN ZFObject *weakProp
839 );
840extern ZFLIB_ZFCore void _ZFP_ZFPropertyLifeCycleCall_setter_retain(
841 ZF_IN const ZFProperty *property
842 , ZF_IN ZFObject *propertyOwnerObject
843 , ZF_IN zfbool accessed
844 , ZF_IN ZFObject *propertyValueOld
845 , ZF_IN ZFObject *propertyValueNew
846 , ZF_IN void (*rawValueStoreCallback)(
847 ZF_IN_OUT void *rawValueStoreToken
848 , ZF_IN ZFObject *value
849 )
850 , ZF_IN void *rawValueStoreToken
851 );
852extern ZFLIB_ZFCore void _ZFP_ZFPropertyLifeCycleCall_setter_assign(
853 ZF_IN const ZFProperty *property
854 , ZF_IN ZFObject *propertyOwnerObject
855 , ZF_IN zfbool accessed
856 , ZF_IN void *propertyValueOld
857 , ZF_IN const void *propertyValueNew
858 , ZF_IN void *(*rawValueStoreCallback)(
859 ZF_IN_OUT void *rawValueStoreToken
860 , ZF_IN const void *value
861 )
862 , ZF_IN void *rawValueStoreToken
863 , ZF_IN ZFObject *weakPropOld
864 , ZF_IN ZFObject *weakPropNew
865 );
866
867ZF_NAMESPACE_GLOBAL_END
868#endif // #ifndef _ZFI_ZFPropertyDeclare_h_
869
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
zfnewPlacement
#define zfnewPlacement(buf, Type,...)
placement new defined for future use
Definition ZFCoreTypeDef_ClassType.h:113
ZF_IN
#define ZF_IN
dummy macro that shows the param used as required input
Definition ZFCoreTypeDef_ClassType.h:191
zfdeletePlacement
#define zfdeletePlacement(instance)
placement delete (instance->~Type()) defined for future use
Definition ZFCoreTypeDef_ClassType.h:116
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:207
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