ZFObjectCore.h

Go to the documentation of this file.

 
#ifndef _ZFI_ZFObjectCore_h_
#define _ZFI_ZFObjectCore_h_
 
#include "zfany.h"
#include "ZFClass.h"
#include "ZFMethod.h"
#include "ZFObjectDeclare.h"
#include "ZFObjectInterface.h"
#include "ZFProperty.h"
#include "ZFObjectMutex.h"
#include "ZFObjectObserver.h"
 
ZF_NAMESPACE_GLOBAL_BEGIN

#define ZFTOKEN_ZFObjectInfoLeft "<"
#define ZFTOKEN_ZFObjectInfoRight ">"
 
// ============================================================
typedef enum {
    ZFObjectInstanceStateOnInit, 
    ZFObjectInstanceStateOnInitFinish, 
    ZFObjectInstanceStateIdle, 
    ZFObjectInstanceStateOnDeallocPrepare, 
    ZFObjectInstanceStateOnDealloc, 
} ZFObjectInstanceState;

#define ZFTOKEN_ZFObjectInstanceStateOnInit "OnInit"
#define ZFTOKEN_ZFObjectInstanceStateOnInitFinish "OnInitFinish"
#define ZFTOKEN_ZFObjectInstanceStateIdle "Idle"
#define ZFTOKEN_ZFObjectInstanceStateOnDeallocPrepare "OnDeallocPrepare"
#define ZFTOKEN_ZFObjectInstanceStateOnDealloc "OnDealloc"
 
// ============================================================
zfclassNotPOD ZFLIB_ZFCore _ZFP_Obj_Base {
public:
    static const ZFClass *ClassData(void) {
        return zfnull;
    }
    static void _ZFP_Obj_initImpl(ZFClass *cls) {}
    static ZFObject *_ZFP_zfAllocCacheIvk(void) {return zfnull;}
};
template<typename T_ZFObject, int valid>
zfclassNotPOD _ZFP_Obj_AllocCk;
zfclassFwd _ZFP_ZFObjectPrivate;
zfclassFwd _ZFP_I_zfweak;
zfclass ZFLIB_ZFCore ZFObject {
    _ZFP_ZFOBJECT_DECLARE(ZFObject, _ZFP_Obj_Base)
    _ZFP_ZFOBJECT_DECLARE_OBJECT(ZFObject, _ZFP_Obj_Base, _ZFP_Obj_Base)
 
public:
    enum {_ZFP_ZFObjectCanAllocPublic = 1};
    static void _ZFP_Obj_initImpl(ZFClass *cls) {}
    static ZFObject *_ZFP_zfAllocCacheIvk(void) {return zfnull;}
    static inline void _ZFP_zfAllocCacheRelease(ZF_IN ZFObject *_obj) {}
    virtual inline void _ZFP_ObjI_onInitIvk(void) {}
    virtual inline void _ZFP_ObjI_onDeallocIvk(void) {}
 
    // ============================================================
    // observer events
public:
    ZFEVENT(ObjectBeforeAlloc)
    ZFEVENT(ObjectAfterAlloc)
    ZFEVENT(ObjectBeforeDealloc)
    ZFEVENT(ObjectPropertyValueOnUpdate)
    ZFEVENT(ObjectPropertyValueOnReset)
 
public:
    zffinal inline zfindex objectRetainCount(void) {
        return _objectRetainCount;
    }
 
    zffinal _ZFP_I_zfweak *_ZFP_ZFObject_weakHolder(void);

    zffinal void objectInfoOfInstanceT(ZF_IN_OUT zfstring &ret) {
        ret += this->classData()->classNameFull();
        ret += "(";
        zfsFromPointerT(ret, this);
        ret += ")";
    }

    zffinal inline zfstring objectInfoOfInstance(void) {
        zfstring ret;
        this->objectInfoOfInstanceT(ret);
        return ret;
    }

    zffinal void objectInfoT(ZF_IN_OUT zfstring &ret);
    zffinal inline zfstring objectInfo(void) {
        zfstring ret;
        this->objectInfoT(ret);
        return ret;
    }
    zffinal inline void _ZFP_ZFObject_objectInfoImpl(ZF_IN_OUT zfstring &ret) {
        this->objectInfoImpl(ret);
    }
 
protected:
    virtual inline void objectInfoImpl(ZF_IN_OUT zfstring &ret) {
        ret += ZFTOKEN_ZFObjectInfoLeft;
        this->objectInfoImplAppend(ret);
        ret += ZFTOKEN_ZFObjectInfoRight;
    }

    virtual inline void objectInfoImplAppend(ZF_IN_OUT zfstring &ret) {
        this->objectInfoOfInstanceT(ret);
    }
 
public:
    zffinal zfidentity objectHash(void);
    zffinal ZFCompareResult objectCompare(ZF_IN ZFObject *anotherObj);
    zffinal ZFCompareResult objectCompareValue(ZF_IN ZFObject *anotherObj);
 
    zffinal zfidentity _ZFP_ZFObject_objectHashImpl(void) {
        return this->objectHashImpl();
    }
    zffinal ZFCompareResult _ZFP_ZFObject_objectCompareImpl(ZF_IN ZFObject *anotherObj) {
        return this->objectCompareImpl(anotherObj);
    }
    zffinal ZFCompareResult _ZFP_ZFObject_objectCompareValueImpl(ZF_IN ZFObject *anotherObj) {
        return this->objectCompareValueImpl(anotherObj);
    }
 
protected:
    virtual inline zfidentity objectHashImpl(void) {
        return zfidentityCalc(this);
    }

    virtual inline ZFCompareResult objectCompareImpl(ZF_IN ZFObject *anotherObj) {
        return ((this == anotherObj) ? ZFCompareEqual : ZFCompareUncomparable);
    }

    virtual inline ZFCompareResult objectCompareValueImpl(ZF_IN ZFObject *anotherObj) {
        return this->objectCompare(anotherObj);
    }
 
public:
    /* ZFMETHOD_MAX_PARAM */
    virtual zfauto invoke(
            ZF_IN const zfstring &methodName
            );
    virtual zfauto invoke(
            ZF_IN const zfstring &methodName
            , ZF_IN ZFObject *param0
            , ZF_IN_OPT ZFObject *param1 = ZFMP_DEF()
            , ZF_IN_OPT ZFObject *param2 = ZFMP_DEF()
            , ZF_IN_OPT ZFObject *param3 = ZFMP_DEF()
            , ZF_IN_OPT ZFObject *param4 = ZFMP_DEF()
            , ZF_IN_OPT ZFObject *param5 = ZFMP_DEF()
            , ZF_IN_OPT ZFObject *param6 = ZFMP_DEF()
            , ZF_IN_OPT ZFObject *param7 = ZFMP_DEF()
            );
    virtual zfbool invokeT(
            ZF_OUT zfauto &ret
            , ZF_OUT_OPT zfstring *errorHint
            , ZF_IN const zfstring &methodName
            , ZF_IN_OPT ZFObject *param0 = ZFMP_DEF()
            , ZF_IN_OPT ZFObject *param1 = ZFMP_DEF()
            , ZF_IN_OPT ZFObject *param2 = ZFMP_DEF()
            , ZF_IN_OPT ZFObject *param3 = ZFMP_DEF()
            , ZF_IN_OPT ZFObject *param4 = ZFMP_DEF()
            , ZF_IN_OPT ZFObject *param5 = ZFMP_DEF()
            , ZF_IN_OPT ZFObject *param6 = ZFMP_DEF()
            , ZF_IN_OPT ZFObject *param7 = ZFMP_DEF()
            );
    virtual zfauto invokeDetail(
            ZF_IN const zfstring &methodName
            , ZF_IN const ZFCoreArray<zfauto> &params
            , ZF_OUT_OPT zfbool *success = zfnull
            , ZF_OUT_OPT zfstring *errorHint = zfnull
            );
 
public:
    zffinal zfbool objectTagExist(void);
    zffinal void objectTag(
            ZF_IN const zfstring &key
            , ZF_IN ZFObject *tag
            );
    zffinal zfany objectTag(ZF_IN const zfstring &key);
    zffinal void objectTagGetAllKeyValue(
            ZF_IN_OUT ZFCoreArray<zfstring> &allKey
            , ZF_IN_OUT ZFCoreArray<zfauto> &allValue
            );
    zffinal inline void objectTagRemove(ZF_IN const zfstring &key) {
        this->objectTag(key, zfnull);
    }

    zffinal zfauto objectTagRemoveAndGet(ZF_IN const zfstring &key);
    zffinal void objectTagRemoveAll(void);
 
public:
    zffinal void observerAdd(
            ZF_IN zfidentity eventId
            , ZF_IN const ZFListener &observer
            , ZF_IN_OPT ZFLevel observerLevel = ZFLevelAppNormal
            );
    zffinal void observerAddForOnce(
            ZF_IN zfidentity eventId
            , ZF_IN const ZFListener &observer
            , ZF_IN_OPT ZFLevel observerLevel = ZFLevelAppNormal
            );
    zffinal void observerRemove(
            ZF_IN zfidentity eventId
            , ZF_IN const ZFListener &callback
            );
    zffinal void observerRemoveAll(ZF_IN zfidentity eventId);
    zffinal void observerRemoveAll(void);
    zffinal zfbool observerHasAdd(void);
    zffinal zfbool observerHasAdd(ZF_IN zfidentity eventId);
    zffinal void observerNotify(
            ZF_IN zfidentity eventId
            , ZF_IN_OPT ZFObject *param0 = zfnull
            , ZF_IN_OPT ZFObject *param1 = zfnull
            );
    zffinal void observerNotifyWithSender(
            ZF_IN ZFObject *customSender
            , ZF_IN zfidentity eventId
            , ZF_IN_OPT ZFObject *param0 = zfnull
            , ZF_IN_OPT ZFObject *param1 = zfnull
            );
    zffinal void observerNotifyReversely(
            ZF_IN zfidentity eventId
            , ZF_IN_OPT ZFObject *param0 = zfnull
            , ZF_IN_OPT ZFObject *param1 = zfnull
            );
    zffinal void observerNotifyReverselyWithSender(
            ZF_IN ZFObject *customSender
            , ZF_IN zfidentity eventId
            , ZF_IN_OPT ZFObject *param0 = zfnull
            , ZF_IN_OPT ZFObject *param1 = zfnull
            );

    zffinal ZFObserver &observerHolder(void);
 
public:
    zffinal void on(
            ZF_IN const zfstring &eventName
            , ZF_IN const ZFListener &observer
            , ZF_IN_OPT ZFLevel observerLevel = ZFLevelAppNormal
            );
    zffinal inline void on(
            ZF_IN zfidentity eventId
            , ZF_IN const ZFListener &observer
            , ZF_IN_OPT ZFLevel observerLevel = ZFLevelAppNormal
            ) {
        this->observerAdd(eventId, observer, observerLevel);
    }

    zffinal inline void onInit(ZF_IN const ZFListener &impl) {
        impl.execute(ZFArgs().sender(this));
    }

    zffinal inline void onDealloc(ZF_IN const ZFListener &impl) {
        this->observerAddForOnce(zfself::E_ObjectBeforeDealloc(), impl);
    }
 
protected:
    virtual void observerOnAdd(ZF_IN zfidentity eventId);
    virtual void observerOnRemove(ZF_IN zfidentity eventId);
    virtual inline void observerOnEvent(ZF_IN const ZFArgs &zfargs) {
    }
 
public:
    void *_ZFP_ZFObjectMutexImpl(void);
    void _ZFP_ZFObjectLock(void);
    void _ZFP_ZFObjectUnlock(void);
    zfbool _ZFP_ZFObjectTryLock(void);
 
    void _ZFP_ZFObject_objectOnInit(void);
    void _ZFP_ZFObject_objectOnInitFinish(void);
    void _ZFP_ZFObject_objectOnInitFromCache(void);
    void _ZFP_ZFObjectCheckRelease(void);
 
protected:
    virtual void objectOnInit(void);
    virtual inline void objectOnInitFinish(void) {
    }

    virtual inline void objectOnDeallocPrepare(void) {
        this->objectTagRemoveAll();
        this->observerRemoveAll();
    }

    virtual void objectOnDealloc(void);

    virtual inline void objectOnRetain(void) {
        ZFCoreAssertWithMessageTrim(_objectRetainCount > 0 || !this->objectInstanceStateCheck(ZFObjectInstanceStateOnDealloc),
            "[ZFObject] retain an object while objectOnDealloc running: %s", this->objectInfoOfInstance());
        ++_objectRetainCount;
    }

    virtual inline void objectOnRelease(void) {
        --_objectRetainCount;
    }
 
public:
    zffinal zfbool objectInstanceStateCheck(ZF_IN ZFObjectInstanceState state);
    zffinal zfbool objectInitRunning(void);
    zffinal zfbool objectDeallocRunning(void);
 
public:
    virtual zfbool objectIsInternal(void);
    virtual zfbool objectIsInternalPrivate(void);
 
public:
    zffinal void _ZFP_ZFObject_objectPropertyValueAttach(ZF_IN const ZFProperty *property);
    zffinal void _ZFP_ZFObject_objectPropertyValueDetach(ZF_IN const ZFProperty *property);
    zffinal inline void _ZFP_ZFObject_objectPropertyValueOnUpdate(
            ZF_IN const ZFProperty *property
            , ZF_IN const void *oldValue
            ) {
        this->objectPropertyValueOnUpdate(property, oldValue);
    }
    zffinal inline void _ZFP_ZFObject_objectPropertyValueOnReset(
            ZF_IN const ZFProperty *property
            ) {
        this->objectPropertyValueOnReset(property);
    }
protected:
    virtual void objectPropertyValueOnUpdate(
            ZF_IN const ZFProperty *property
            , ZF_IN const void *oldValue
            );
    virtual void objectPropertyValueOnReset(
            ZF_IN const ZFProperty *property
            );
 
    // ============================================================
public:
    zffinal void _ZFP_ZFObject_zfAllocCacheRelease(ZF_IN _ZFP_zfAllocCacheReleaseCallback callback);
    zffinal _ZFP_zfAllocCacheReleaseCallback _ZFP_ZFObject_zfAllocCacheRelease(void);
    zffinal ZFObject *_ZFP_ZFObject_ZFImplementDynamicOwnerOrSelf(void);
    zffinal ZFObject *_ZFP_ZFObject_ZFImplementDynamicHolder(ZF_IN const ZFClass *clsToImplement);
 
private:
    friend zfclassFwd ZFClass;
    friend zfclassFwd ZFObserver;
    friend zfclassFwd _ZFP_ZFObserverPrivate;
    template<typename T_ZFObject, int valid>
    friend zfclassFwd _ZFP_Obj_AllocCk;
    friend void _ZFP_zfRetainAction(ZF_IN ZFObject *obj);
    friend void _ZFP_zfReleaseAction(ZF_IN ZFObject *obj);
public:
    const ZFClass *_ZFP_ZFObject_classDynamic;
private:
    _ZFP_ZFObjectPrivate *d;
    zfuint _objectRetainCount;
    zfuint _stateFlags;
protected:
    ZFObject(void)
    : _ZFP_ZFObject_classDynamic(zfnull)
    , d(zfnull)
    , _objectRetainCount(1)
    , _stateFlags(0)
    {
    }
    virtual ~ZFObject(void) {
    }
};

extern ZFLIB_ZFCore zfany ZFObjectCast(ZF_IN const ZFClass *cls, ZF_IN const zfany &obj);
 
ZF_NAMESPACE_GLOBAL_END
#endif // #ifndef _ZFI_ZFObjectCore_h_