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