ZFCallback.h

Go to the documentation of this file.

 
#ifndef _ZFI_ZFCallback_h_
#define _ZFI_ZFCallback_h_
 
#include "ZFMethod.h"
#include "zfcast.h"
#include "ZFSerializableData.h"
 
ZF_NAMESPACE_GLOBAL_BEGIN
 
zfclassFwd ZFListener;
 
// ============================================================
typedef enum {
    ZFCallbackTypeDummy, 
    ZFCallbackTypeMethod, 
    ZFCallbackTypeMemberMethod, 
    ZFCallbackTypeRawFunction, 
    ZFCallbackTypeLambda, 
} ZFCallbackType;

#define ZFTOKEN_ZFCallbackTypeDummy "Dummy"
#define ZFTOKEN_ZFCallbackTypeMethod "Method"
#define ZFTOKEN_ZFCallbackTypeMemberMethod "MemeberMethod"
#define ZFTOKEN_ZFCallbackTypeRawFunction "RawFunction"
#define ZFTOKEN_ZFCallbackTypeLambda "Lambda"
 
// ============================================================
// callback invoker
extern ZFLIB_ZFCore void _ZFP_ZFCallback_executeNullCallback(void);
#define _ZFP_ZFCALLBACK_INVOKER(N) \
 \
    template<typename T_ReturnType ZFM_REPEAT(N, ZFM_REPEAT_TEMPLATE, ZFM_COMMA, ZFM_COMMA)> \
    T_ReturnType executeExact(ZFM_REPEAT(N, ZFM_REPEAT_PARAM, ZFM_EMPTY, ZFM_COMMA)) const { \
        switch(this->callbackType()) { \
            case ZFCallbackTypeMethod: \
            case ZFCallbackTypeMemberMethod: \
                return this->callbackMethod()->executeExact<T_ReturnType ZFM_REPEAT(N, ZFM_REPEAT_TYPE, ZFM_COMMA, ZFM_COMMA)>( \
                        this->callbackOwnerObject() \
                        ZFM_REPEAT(N, ZFM_REPEAT_NAME, ZFM_COMMA, ZFM_COMMA) \
                    ); \
            case ZFCallbackTypeRawFunction: \
                return ((T_ReturnType (*)(ZFM_REPEAT(N, ZFM_REPEAT_TYPE, ZFM_EMPTY, ZFM_COMMA)))(this->callbackRawFunction())) \
                    (ZFM_REPEAT(N, ZFM_REPEAT_NAME, ZFM_EMPTY, ZFM_COMMA)); \
            case ZFCallbackTypeLambda: { \
                ZFCallback holder_(*this); \
                return ((T_ReturnType (*)(void * ZFM_REPEAT(N, ZFM_REPEAT_TYPE, ZFM_COMMA, ZFM_COMMA)))(this->callbackLambdaInvoker()))( \
                        this->callbackLambdaImpl() \
                        ZFM_REPEAT(N, ZFM_REPEAT_NAME, ZFM_COMMA, ZFM_COMMA) \
                    ); \
            } \
            case ZFCallbackTypeDummy: \
            default: \
                _ZFP_ZFCallback_executeNullCallback(); \
                return ((T_ReturnType (*)(void))(zfnull)) (); \
        } \
    }
 
typedef void (*_ZFP_ZFCallbackLambdaDeleteCallback)(void *);
 
// ============================================================
// ZFCallback
zfclassFwd ZFSerializableData;
zfclassFwd _ZFP_ZFCallbackPrivate;
zfclassLikePOD ZFLIB_ZFCore ZFCallback {
public:
    ZFCallback(void);
    ZFCallback(ZF_IN const zfnullT &dummy);
    ZFCallback(ZF_IN const ZFCallback &ref);
    ZFCallback &operator = (ZF_IN const ZFCallback &ref);
    ZFCallback &operator = (ZF_IN const zfnullT &dummy);
    ~ZFCallback(void);
    zfbool operator == (ZF_IN const ZFCallback &ref) const {return (this->objectCompare(ref) == ZFCompareEqual);}
    zfbool operator != (ZF_IN const ZFCallback &ref) const {return (this->objectCompare(ref) != ZFCompareEqual);}
    zfbool operator == (ZF_IN const zfnullT &dummy) const {return (d == zfnull);}
    zfbool operator != (ZF_IN const zfnullT &dummy) const {return (d != zfnull);}
    operator bool (void) const {return this->valid();}
    inline void _ZFP_ZFCallback_d(ZF_IN _ZFP_ZFCallbackPrivate *d) {
        this->d = d;
    }
    inline _ZFP_ZFCallbackPrivate *_ZFP_ZFCallback_d(void) const {
        return d;
    }
    static ZFCallback _ZFP_ZFCallbackCreateMethod(ZF_IN const ZFMethod *callbackMethod);
    static ZFCallback _ZFP_ZFCallbackCreateMemberMethod(
            ZF_IN ZFObject *callbackOwnerObject
            , ZF_IN const ZFMethod *callbackMethod
            );
    static ZFCallback _ZFP_ZFCallbackCreateRawFunction(ZF_IN ZFFuncAddrType callbackRawFunction);
    static ZFCallback _ZFP_ZFCallbackCreateLambda(
            ZF_IN void *callbackLambdaImpl
            , ZF_IN _ZFP_ZFCallbackLambdaDeleteCallback callbackLambdaImplDestroy
            , ZF_IN ZFFuncAddrType callbackLambdaInvoker
            );
 
    _ZFP_ZFCALLBACK_INVOKER(0)
    _ZFP_ZFCALLBACK_INVOKER(1)
    _ZFP_ZFCALLBACK_INVOKER(2)
    _ZFP_ZFCALLBACK_INVOKER(3)
    _ZFP_ZFCALLBACK_INVOKER(4)
    _ZFP_ZFCALLBACK_INVOKER(5)
    _ZFP_ZFCALLBACK_INVOKER(6)
    _ZFP_ZFCALLBACK_INVOKER(7)
    _ZFP_ZFCALLBACK_INVOKER(8)
    /* ZFMETHOD_MAX_PARAM */
 
public:
    zffinal zfindex objectRetainCount(void) const;

    zffinal void objectInfoT(ZF_IN_OUT zfstring &ret) const;
    zffinal inline zfstring objectInfo(void) const {
        zfstring ret;
        this->objectInfoT(ret);
        return ret;
    }

    zffinal ZFCompareResult objectCompare(ZF_IN const ZFCallback &ref) const;
    zffinal ZFCompareResult objectCompareByInstance(ZF_IN const ZFCallback &ref) const {
        return ((d == ref.d) ? ZFCompareEqual : ZFCompareUncomparable);
    }
 
public:
    zffinal void callbackRelease(void);

    zffinal void callbackClear(void);

    zffinal void callbackClearPrepareAdd(
            ZF_IN const ZFListener &observer
            , ZF_IN_OPT ZFLevel observerLevel = ZFLevelAppNormal
            ) const;
    zffinal void callbackClearPrepareRemove(ZF_IN const ZFListener &observer) const;

    zffinal void callbackId(ZF_IN const zfstring &callbackId);
    zffinal const zfstring &callbackId(void) const;

    zffinal zfidentity callbackHash(void) const;

    zffinal void callbackTag(
            ZF_IN const zfstring &key
            , ZF_IN ZFObject *tag
            );
    zffinal zfany callbackTag(ZF_IN const zfstring &key) const;
    zffinal void callbackTagGetAllKeyValue(
            ZF_IN_OUT ZFCoreArray<zfstring> &allKey
            , ZF_IN_OUT ZFCoreArray<zfauto> &allValue
            ) const;
    inline void callbackTagRemove(ZF_IN const zfstring &key) {
        this->callbackTag(key, zfnull);
    }

    zffinal zfauto callbackTagRemoveAndGet(ZF_IN const zfstring &key);
    zffinal void callbackTagRemoveAll(void);

    zffinal inline zfbool valid(void) const {
        return (this->callbackType() != ZFCallbackTypeDummy);
    }

    zffinal ZFCallbackType callbackType(void) const;

    zffinal zfany callbackOwnerObject(void) const;

    zffinal const ZFMethod *callbackMethod(void) const;

    zffinal ZFFuncAddrType callbackRawFunction(void) const;

    zffinal void *callbackLambdaImpl(void) const;
    zffinal ZFFuncAddrType callbackLambdaInvoker(void) const;
    zffinal void _ZFP_ZFCallback_callbackLambdaInvoker(ZF_IN ZFFuncAddrType v) const;

    zffinal void callbackOwnerObjectRetain(void) const;
    zffinal void callbackOwnerObjectRelease(void) const;
 
    // ============================================================
public:
    zffinal void callbackInfoCopy(ZF_IN const ZFCallback &src) {
        this->callbackId(src.callbackId());
        if(src.callbackSerializeDisable()) {
            this->callbackSerializeDisable(zftrue);
        }
        else {
            this->callbackSerializeType(src.callbackSerializeType());
            this->callbackSerializeData(src.callbackSerializeData());
        }
        this->pathInfo(src.pathInfo());
    }
 
    // ============================================================
    // callback serialize logic
public:
    zffinal void callbackSerializeType(ZF_IN const zfstring &customType);
    zffinal const zfstring &callbackSerializeType(void) const;
    zffinal void callbackSerializeData(ZF_IN const ZFSerializableData &customData);
    zffinal ZFSerializableData callbackSerializeData(void) const;

    zffinal void callbackSerializeDisable(ZF_IN zfbool disable) {
        this->callbackSerializeType(disable ? ZFSerializeDisable : zfnull);
    }

    zffinal zfbool callbackSerializeDisable(void) const {
        return zfstringIsEqual(this->callbackSerializeType(), ZFSerializeDisable);
    }
 
    // ============================================================
    // local path logic
public:
    zffinal ZFPathInfo pathInfo(void) const;
    zffinal void pathInfo(ZF_IN const ZFPathInfo &pathInfo);
 
private:
    _ZFP_ZFCallbackPrivate *d;
};
ZFCOMPARER_DEFAULT_DECLARE(ZFCallback, ZFCallback, {
    return v0 == v1 ? ZFCompareEqual : ZFCompareUncomparable;
})
 
// ============================================================
// ZFCallback create
#define ZFCallbackForMethod(zfmethod) \
    ZFCallback::_ZFP_ZFCallbackCreateMethod(zfmethod)
 

#define ZFCallbackForMemberMethod(obj, zfmethod) \
    ZFCallback::_ZFP_ZFCallbackCreateMemberMethod(obj, zfmethod)

#define ZFCallbackForFunc(callbackRawFunction) \
    ZFCallback::_ZFP_ZFCallbackCreateRawFunction( \
        (ZFFuncAddrType)(void (*)(const ZFArgs &))(callbackRawFunction) \
        )
 
// ============================================================
// child callback declare
#define _ZFP_ZFCALLBACK_DECLARE_BEGIN(ZFLIB_, CallbackTypeName, ParentType) \
    zfclassLikePOD ZFLIB_ CallbackTypeName : zfextend ParentType { \
        _ZFP_ZFCALLBACK_DECLARE_CONSTRUCTORS(CallbackTypeName, ParentType) \
    public:
#define _ZFP_ZFCALLBACK_DECLARE_END(ZFLIB_, CallbackTypeName, ParentType) \
    }; \
    ZFOUTPUT_TYPE(CallbackTypeName, {v.objectInfoT(s);})
#define _ZFP_ZFCALLBACK_DECLARE_CONSTRUCTORS(CallbackTypeName, ParentType) \
    public: \
 \
        CallbackTypeName(void) \
        : ParentType() \
        { \
        } \
        CallbackTypeName(ZF_IN const zfnullT &dummy) \
        : ParentType(dummy) \
        { \
        } \
        CallbackTypeName(ZF_IN const ZFCallback &ref) \
        : ParentType(ref) \
        { \
        } \
        CallbackTypeName(ZF_IN const CallbackTypeName &ref) \
        : ParentType((const ZFCallback &)ref) \
        { \
        } \
        CallbackTypeName &operator = (ZF_IN const zfnullT &dummy) { \
            ParentType::operator = (dummy); \
            return *this; \
        } \
        CallbackTypeName &operator = (ZF_IN const ZFCallback &ref) { \
            ParentType::operator = (ref); \
            return *this; \
        } \
        CallbackTypeName &operator = (ZF_IN const CallbackTypeName &ref) { \
            ParentType::operator = ((const ZFCallback &)ref); \
            return *this; \
        } \

#define ZFCALLBACK_DECLARE_END(ZFLIB_, CallbackTypeName, ParentType) \
    _ZFP_ZFCALLBACK_DECLARE_END(ZFLIB_, CallbackTypeName, ParentType) \
    _ZFP_ZFCALLBACK_DECLARE_END_REG(ZFLIB_, CallbackTypeName, ParentType)
#define _ZFP_ZFCALLBACK_DECLARE_END_REG(ZFLIB_, CallbackTypeName, ParentType) \
    ZFTYPEID_ALIAS_DECLARE(ZFLIB_, ZFCallback, ZFCallback, CallbackTypeName, CallbackTypeName) \
    ZFTYPEID_ALIAS_REG_CUSTOM(ZFLIB_, ZFCallback, ZFCallback, CallbackTypeName, CallbackTypeName, _ZFP_ZFTYPEID_ALIAS_VALUE_ACCESS_REINTERPRET_CAST)

#define ZFCALLBACK_DECLARE_BEGIN(ZFLIB_, CallbackTypeName, ParentType) \
    _ZFP_ZFCALLBACK_DECLARE_BEGIN(ZFLIB_, CallbackTypeName, ParentType)

#define ZFCALLBACK_DECLARE(ZFLIB_, CallbackTypeName, ParentType) \
    ZFCALLBACK_DECLARE_BEGIN(ZFLIB_, CallbackTypeName, ParentType) \
    ZFCALLBACK_DECLARE_END(ZFLIB_, CallbackTypeName, ParentType)

#define ZFCALLBACK_DEFINE(CallbackTypeName, ParentType) \
    ZFTYPEID_ALIAS_DEFINE(ZFCallback, ZFCallback, CallbackTypeName, CallbackTypeName)
 
ZF_NAMESPACE_GLOBAL_END
#endif // #ifndef _ZFI_ZFCallback_h_