ZFObjectObserver.h

Go to the documentation of this file.

 
#ifndef _ZFI_ZFObjectObserver_h_
#define _ZFI_ZFObjectObserver_h_
 
#include "ZFCallback.h"
#include "ZFIdMap.h"
#include "ZFArgs.h"
#include "ZFListenerDeclare.h"
 
#if ZF_ENV_LAMBDA
#include <functional>
#endif
 
ZF_NAMESPACE_GLOBAL_BEGIN
 
// ============================================================
ZFCALLBACK_DECLARE_BEGIN(ZFLIB_ZFCore, ZFListener, ZFCallback)
public:
    inline zfbool execute(void) const {
        if(this->valid()) {
            ZFArgs zfargs;
            ZFCallback::executeExact<void, const ZFArgs &>(zfargs);
            return zftrue;
        }
        else {
            return zffalse;
        }
    }

    inline zfbool execute(ZF_IN const ZFArgs &zfargs) const {
        if(this->valid()) {
            ZFCallback::executeExact<void, const ZFArgs &>(zfargs);
            return zftrue;
        }
        else {
            return zffalse;
        }
    }

    inline zfbool operator () (void) const {
        if(this->valid()) {
            ZFArgs zfargs;
            ZFCallback::executeExact<void, const ZFArgs &>(zfargs);
            return zftrue;
        }
        else {
            return zffalse;
        }
    }

    inline zfbool operator () (ZF_IN const ZFArgs &zfargs) const {
        if(this->valid()) {
            ZFCallback::executeExact<void, const ZFArgs &>(zfargs);
            return zftrue;
        }
        else {
            return zffalse;
        }
    }

public:
    ZFListener(
            ZF_IN ZFObject *owner
            , ZF_IN const ZFMethod *f) {
        ZFCallback::operator = (ZFCallbackForMemberMethod(owner, f));
    }
    ZFListener(ZF_IN const ZFMethod *f) {
        ZFCallback::operator = (ZFCallbackForMethod(f));
    }
    ZFListener &operator = (ZF_IN const ZFMethod *f) {
        ZFCallback::operator = (ZFCallbackForMethod(f));
        return *this;
    }

public:
    typedef void (*FUNC_TYPE)(ZF_IN const ZFArgs &zfargs);
    ZFListener(ZF_IN FUNC_TYPE f) {
        FUNC_TYPE fTmp = f;
        ZFLISTENER_1(wrapper
                , FUNC_TYPE, fTmp
                ) {
            fTmp(zfargs);
        } ZFLISTENER_END()
        ZFCallback::operator = ((const ZFCallback &)wrapper);
    }
    ZFListener &operator = (ZF_IN FUNC_TYPE f) {
        FUNC_TYPE fTmp = f;
        ZFLISTENER_1(wrapper
                , FUNC_TYPE, fTmp
                ) {
            fTmp(zfargs);
        } ZFLISTENER_END()
        ZFCallback::operator = ((const ZFCallback &)wrapper);
        return *this;
    }

#if ZF_ENV_LAMBDA
public:
    template<typename T_Func>
    ZFListener(ZF_IN T_Func f) {
        ZFLISTENER_1(wrapper
                , std::function<void(const ZFArgs &)>, f
                ) {
            f(zfargs);
        } ZFLISTENER_END()
        ZFCallback::operator = ((const ZFCallback &)wrapper);
    }
    template<typename T_Func>
    ZFListener &operator = (ZF_IN T_Func f) {
        ZFLISTENER_1(wrapper
                , std::function<void(const ZFArgs &)>, f
                ) {
            f(zfargs);
        } ZFLISTENER_END()
        ZFCallback::operator = ((const ZFCallback &)wrapper);
        return *this;
    }
#endif
_ZFP_ZFCALLBACK_DECLARE_END_NO_ALIAS(ZFLIB_ZFCore, ZFListener, ZFCallback)
 
// ============================================================
// ZFObserver
zfclassFwd _ZFP_ZFObserverPrivate;
zffinal zfclassLikePOD ZFLIB_ZFCore ZFObserver {
public:
    ZFObserver(void);
    ZFObserver(ZF_IN ZFObserver const &ref);
    ~ZFObserver(void);
    ZFObserver &operator = (ZF_IN ZFObserver const &ref);
    zfbool operator == (ZF_IN ZFObserver const &ref) const;
    inline zfbool operator != (ZF_IN ZFObserver const &ref) const {return !this->operator == (ref);}
 
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) const;
    zffinal zfbool observerHasAdd(ZF_IN zfidentity eventId) const;
    zffinal inline void observerNotify(
            ZF_IN zfidentity eventId
            , ZF_IN_OPT ZFObject *param0 = zfnull
            , ZF_IN_OPT ZFObject *param1 = zfnull
            ) const {
        this->observerNotifyWithSender(this->observerOwner(), eventId, param0, param1);
    }

    zffinal void observerNotifyWithSender(
            ZF_IN ZFObject *customSender
            , ZF_IN zfidentity eventId
            , ZF_IN_OPT ZFObject *param0 = zfnull
            , ZF_IN_OPT ZFObject *param1 = zfnull
            ) const;
    zffinal inline void observerNotifyReversely(
            ZF_IN zfidentity eventId
            , ZF_IN_OPT ZFObject *param0 = zfnull
            , ZF_IN_OPT ZFObject *param1 = zfnull
            ) const {
        this->observerNotifyReverselyWithSender(this->observerOwner(), eventId, param0, param1);
    }

    zffinal void observerNotifyReverselyWithSender(
            ZF_IN ZFObject *customSender
            , ZF_IN zfidentity eventId
            , ZF_IN_OPT ZFObject *param0 = zfnull
            , ZF_IN_OPT ZFObject *param1 = zfnull
            ) const;
 
public:
    zffinal inline void on(
            ZF_IN zfidentity eventId
            , ZF_IN const ZFListener &observer
            , ZF_IN_OPT ZFLevel observerLevel = ZFLevelAppNormal
            ) {
        this->observerAdd(eventId, observer, observerLevel);
    }
 
public:
    zffinal void observerHasAddStateAttach(
            ZF_IN zfidentity eventId
            , ZF_IN_OUT zfuint *flag
            , ZF_IN_OUT zfuint flagBit
            );
    zffinal void observerHasAddStateDetach(
            ZF_IN zfidentity eventId
            , ZF_IN_OUT zfuint *flag
            , ZF_IN_OUT zfuint flagBit
            );
 
public:
    void objectInfoT(ZF_OUT zfstring &ret) const;
    zfstring objectInfo(void) const {
        zfstring ret;
        this->objectInfoT(ret);
        return ret;
    }
 
public:
    zffinal zfany observerOwner(void) const;
    zffinal void _ZFP_ZFObserver_observerOwner(ZF_IN ZFObject *obj);
 
private:
    _ZFP_ZFObserverPrivate *d;
};
 
// ============================================================
extern ZFLIB_ZFCore ZFObserver &ZFGlobalObserver(void);
 
// ============================================================
// observer
#define ZFEVENT(YourEvent) \
    ZFIDMAP_DETAIL(E_, YourEvent)

#define ZFEVENT_INLINE(YourEvent) \
    ZFIDMAP_DETAIL_INLINE(E_, YourEvent)

#define ZFEVENT_REGISTER(YourClass, YourEvent) \
    ZFIDMAP_REGISTER_DETAIL(YourClass, E_, YourEvent)
 
// ============================================================
#define ZFEVENT_GLOBAL(ZFLIB_, YourEvent) \
    ZFIDMAP_GLOBAL_DETAIL(ZFLIB_, E_, YourEvent)

#define ZFEVENT_GLOBAL_REGISTER(YourEvent) \
    ZFIDMAP_GLOBAL_REGISTER_DETAIL(E_, YourEvent)
 
// ============================================================
inline zfstring ZFEventNameForId(ZF_IN zfidentity idValue) {
    return ZFIdMapNameForId(idValue);
}

inline zfidentity ZFEventIdForName(ZF_IN const zfstring &idName) {
    return ZFIdMapIdForName(idName);
}

inline zfidentity ZFEventDynamicRegister(ZF_IN const zfstring &idName) {
    return ZFIdMapDynamicRegister(idName);
}

inline void ZFEventDynamicUnregister(ZF_IN zfidentity idValue) {
    ZFIdMapDynamicUnregister(idValue);
}
 
ZF_NAMESPACE_BEGIN_REGISTER(ZFGlobalEvent, ZF_NAMESPACE_GLOBAL)
ZF_NAMESPACE_END(ZFGlobalEvent)
 
ZF_NAMESPACE_GLOBAL_END
#endif // #ifndef _ZFI_ZFObjectObserver_h_