ZFMethod.h

Go to the documentation of this file.

 
#ifndef _ZFI_ZFMethod_h_
#define _ZFI_ZFMethod_h_
 
#include "ZFObjectClassTypeFwd.h"
#include "ZFMethodGenericInvoker.h"
ZF_NAMESPACE_GLOBAL_BEGIN
 
// ============================================================
typedef enum {
    ZFMethodAccessTypePublic, 
    ZFMethodAccessTypeProtected, 
    ZFMethodAccessTypePrivate, 
} ZFMethodAccessType;

#define ZFTOKEN_ZFMethodAccessTypePublic "public"
#define ZFTOKEN_ZFMethodAccessTypeProtected "protected"
#define ZFTOKEN_ZFMethodAccessTypePrivate "private"
 
// ============================================================
#define _ZFP_ZFMethodType_ZFMethodTypeNormal()
#define _ZFP_ZFMethodType_ZFMethodTypeStatic() static
#define _ZFP_ZFMethodType_ZFMethodTypeVirtual() virtual
#define _ZFP_ZFMethodType(ZFMethodType_) _ZFP_ZFMethodType_##ZFMethodType_()
 
#define _ZFP_ZFMethodTypeChain_ZFMethodTypeNormal(...) __VA_ARGS__
#define _ZFP_ZFMethodTypeChain_ZFMethodTypeStatic(...)
#define _ZFP_ZFMethodTypeChain_ZFMethodTypeVirtual(...) __VA_ARGS__
#define _ZFP_ZFMethodTypeChain(ZFMethodType_, ...) _ZFP_ZFMethodTypeChain_##ZFMethodType_(__VA_ARGS__)

typedef enum {
    ZFMethodTypeNormal, 
    ZFMethodTypeStatic, 
    ZFMethodTypeVirtual, 
} ZFMethodType;

#define ZFTOKEN_ZFMethodTypeNormal ""
#define ZFTOKEN_ZFMethodTypeStatic "static"
#define ZFTOKEN_ZFMethodTypeVirtual "virtual"
 
// ============================================================
zfclassFwd ZFObject;
zfclassFwd ZFClass;
#define _ZFP_ZFMETHOD_INVOKER(N) \
 \
    template<typename T_ReturnType ZFM_REPEAT(N, ZFM_REPEAT_TEMPLATE, ZFM_COMMA, ZFM_COMMA)> \
    inline T_ReturnType executeExact(ZFObject *obj ZFM_REPEAT(N, ZFM_REPEAT_PARAM, ZFM_COMMA, ZFM_COMMA)) const { \
        if(!this->preferGenericInvoker()) { \
            return reinterpret_cast< \
                    T_ReturnType (*)(const ZFMethod *, zfany const & ZFM_REPEAT(N, ZFM_REPEAT_PARAM, ZFM_COMMA, ZFM_COMMA)) \
                    >(this->methodInvoker()) \
                (this, obj ZFM_REPEAT(N, ZFM_REPEAT_NAME, ZFM_COMMA, ZFM_COMMA)); \
        } \
        else { \
            return _ZFP_mGII<T_ReturnType ZFM_REPEAT(N, ZFM_REPEAT_TYPE, ZFM_COMMA, ZFM_COMMA)>(\
                    this, obj ZFM_REPEAT(N, ZFM_REPEAT_NAME, ZFM_COMMA, ZFM_COMMA) \
                ); \
        } \
    } \
    /* this would save much binary size by removing support of dynamic method forwarding, for internal impl use only, use with caution */ \
    template<typename T_ReturnType ZFM_REPEAT(N, ZFM_REPEAT_TEMPLATE, ZFM_COMMA, ZFM_COMMA)> \
    inline T_ReturnType _ZFP_execute(ZFObject *obj ZFM_REPEAT(N, ZFM_REPEAT_PARAM, ZFM_COMMA, ZFM_COMMA)) const { \
        return reinterpret_cast< \
                T_ReturnType (*)(const ZFMethod *, zfany const & ZFM_REPEAT(N, ZFM_REPEAT_PARAM, ZFM_COMMA, ZFM_COMMA)) \
                >(this->methodInvoker()) \
            (this, obj ZFM_REPEAT(N, ZFM_REPEAT_NAME, ZFM_COMMA, ZFM_COMMA)); \
    }
 
// ============================================================
#define _ZFP_ZFMethodNoDefaultParam ZFM_EMPTY
#define _ZFP_ZFMethodDefaultParam(DefaultValue) \
    = (DefaultValue) ZFM_EMPTY
 
// tricks to solve recursive macro
#define _ZFP_mM_EMPTY(...) // for ZFMP
#define _ZFP_mM_EXPAND(...) __VA_ARGS__ // for ZFMP
#define _ZFP_mP_EXPAND(...) __VA_ARGS__ // for param expand
#define _ZFP_mD_EXPAND(...) __VA_ARGS__ // for method declare expand
#define ZFMP_IN(ParamType, paramName) \
    _ZFP_mM_EXPAND, ParamType, paramName, _ZFP_mM_EMPTY, _ZFP_ZFMethodNoDefaultParam

#define ZFMP_IN_OPT(ParamType, paramName, DefaultValue) \
    _ZFP_mM_EXPAND, ParamType, paramName, _ZFP_mM_EXPAND, _ZFP_ZFMethodDefaultParam(DefaultValue)

#define ZFMP_OUT(ParamType, paramName) \
    _ZFP_mM_EXPAND, ParamType, paramName, _ZFP_mM_EMPTY, _ZFP_ZFMethodNoDefaultParam

#define ZFMP_OUT_OPT(ParamType, paramName, DefaultValue) \
    _ZFP_mM_EXPAND, ParamType, paramName, _ZFP_mM_EXPAND, _ZFP_ZFMethodDefaultParam(DefaultValue)

#define ZFMP_IN_OUT(ParamType, paramName) \
    _ZFP_mM_EXPAND, ParamType, paramName, _ZFP_mM_EMPTY, _ZFP_ZFMethodNoDefaultParam

#define ZFMP_IN_OUT_OPT(ParamType, paramName, DefaultValue) \
    _ZFP_mM_EXPAND, ParamType, paramName, _ZFP_mM_EXPAND, _ZFP_ZFMethodDefaultParam(DefaultValue)
 
#define _ZFP_ZFMP_DUMMY() \
    _ZFP_mM_EMPTY, ParamType, paramName, _ZFP_mM_EMPTY, _ZFP_ZFMethodNoDefaultParam
 
// ============================================================
zfclassFwd ZFListener;
extern ZFLIB_ZFCore const ZFListener &_ZFP_ZFMethod_paramDefaultValueCallbackDummy(void);
zfclassLikePOD ZFLIB_ZFCore _ZFP_ZFMethodMP {
public:
    zfuint paramCount;
    ZFSigName paramTypeId[ZFMETHOD_MAX_PARAM];
    ZFSigName paramName[ZFMETHOD_MAX_PARAM];
    ZFListener *paramDefaultValueCallback[ZFMETHOD_MAX_PARAM];
public:
    _ZFP_ZFMethodMP &add(
            ZF_IN const zfstring &paramTypeId
            , ZF_IN const zfstring &paramName
            , ZF_IN const ZFListener &paramDefaultValueCallback
            );
public:
    _ZFP_ZFMethodMP(void) : paramCount(0) {
    }
    ~_ZFP_ZFMethodMP(void);
private:
    _ZFP_ZFMethodMP(ZF_IN const _ZFP_ZFMethodMP &ref);
};
 
// ============================================================
zfclassFwd _ZFP_ZFMethodPrivate;
zffinal zfclassNotPOD ZFLIB_ZFCore ZFMethod {
    ZFCLASS_DISALLOW_COPY_CONSTRUCTOR(ZFMethod)
 
public:
    void _ZFP_ZFMethod_init(
            ZF_IN zfbool isUserRegister
            , ZF_IN zfbool isDynamicRegister
            , ZF_IN ZFObject *dynamicRegisterUserData
            , ZF_IN ZFFuncAddrType methodInvoker
            , ZF_IN ZFMethodGenericInvoker methodGenericInvoker
            , ZF_IN ZFMethodType methodType
            , ZF_IN const zfstring &methodName
            , ZF_IN const zfstring &returnTypeId
            , ZF_IN const _ZFP_ZFMethodMP &mp
            );
    void _ZFP_ZFMethod_initClassMemberType(
            ZF_IN const ZFClass *ownerClass
            , ZF_IN ZFMethodAccessType accessType
            );
    void _ZFP_ZFMethod_initFuncType(ZF_IN const zfstring &methodNamespace);
    ZFMethod(void);
    ~ZFMethod(void);
 
public:
    _ZFP_ZFMETHOD_INVOKER(0)
    _ZFP_ZFMETHOD_INVOKER(1)
    _ZFP_ZFMETHOD_INVOKER(2)
    _ZFP_ZFMETHOD_INVOKER(3)
    _ZFP_ZFMETHOD_INVOKER(4)
    _ZFP_ZFMETHOD_INVOKER(5)
    _ZFP_ZFMETHOD_INVOKER(6)
    _ZFP_ZFMETHOD_INVOKER(7)
    _ZFP_ZFMETHOD_INVOKER(8)
    /* ZFMETHOD_MAX_PARAM */
 
public:
    void objectInfoT(ZF_IN_OUT zfstring &ret) const;
    zfstring objectInfo(void) const {
        zfstring ret;
        this->objectInfoT(ret);
        return ret;
    }
 
    // ============================================================
    // general
public:
    const ZFMethod *aliasFrom(void) const;
    const ZFCoreArray<const ZFMethod *> &aliasTo(void) const;

    inline zfidentity methodId(void) const {
        return _methodId.sigId();
    }

    inline zfbool isUserRegister(void) const {
        return ZFBitTest(_stateFlags, _stateFlags_isUserRegister);
    }

    inline zfany userRegisterUserData(void) const {
        return this->isUserRegister() ? _methodUserData : zfnull;
    }

    void userRegisterUserData(ZF_IN ZFObject *userData) const;
    inline zfbool isDynamicRegister(void) const {
        return ZFBitTest(_stateFlags, _stateFlags_isDynamicRegister);
    }

    inline zfany dynamicRegisterUserData(void) const {
        return this->isDynamicRegister() ? _methodUserData : zfnull;
    }

    inline const zfstring &methodName(void) const {
        return _methodName;
    }

    inline const zfstring &returnTypeId(void) const {
        return _returnTypeId;
    }

    inline zfindex paramCount(void) const {
        return (zfindex)_paramCount;
    }

    inline zfindex paramCountMin(void) const {
        return (zfindex)_paramCountMin;
    }

    zfbool paramTypeIdIsMatch(
            ZF_IN_OPT const zfchar *paramTypeId0 = zfnull
            , ZF_IN_OPT const zfchar *paramTypeId1 = zfnull
            , ZF_IN_OPT const zfchar *paramTypeId2 = zfnull
            , ZF_IN_OPT const zfchar *paramTypeId3 = zfnull
            , ZF_IN_OPT const zfchar *paramTypeId4 = zfnull
            , ZF_IN_OPT const zfchar *paramTypeId5 = zfnull
            , ZF_IN_OPT const zfchar *paramTypeId6 = zfnull
            , ZF_IN_OPT const zfchar *paramTypeId7 = zfnull
            ) const;
    zfbool paramTypeIdIsMatch(ZF_IN const ZFMethod *method) const;
    inline const zfstring &paramTypeIdAt(ZF_IN zfindex index) const {
        ZFCoreAssert(index < this->paramCount());
        return this->_ZFP_ZFMethod_paramTypeIdList()[index];
    }

    inline const zfstring &paramNameAt(ZF_IN zfindex index) const {
        ZFCoreAssert(index < this->paramCount());
        return this->_ZFP_ZFMethod_paramNameList()[index];
    }
    inline zfstring paramNameFixedAt(ZF_IN zfindex index) const {
        zfstring ret = this->paramNameAt(index);
        if(!ret) {
            ret = zfstr("p%s", index);
        }
        return ret;
    }
    const ZFListener &paramDefaultValueCallbackAt(ZF_IN zfindex index) const;
    zfauto paramDefaultValueAt(ZF_IN zfindex index) const;
    inline zfindex paramDefaultBeginIndex(void) const {
        return (_paramDefaultBeginIndex == (zfbyte)-1 ? zfindexMax() : (zfindex)_paramDefaultBeginIndex);
    }

    void paramInfoT(ZF_IN_OUT zfstring &ret) const;
    zfstring paramInfo(void) const {
        zfstring ret;
        this->paramInfoT(ret);
        return ret;
    }

    inline ZFFuncAddrType methodInvoker(void) const {
        return _methodInvoker;
    }

    inline ZFMethodGenericInvoker methodGenericInvoker(void) const {
        return _methodGenericInvoker;
    }
    /* ZFMETHOD_MAX_PARAM */
    zfauto methodInvoke(
            ZF_IN_OPT ZFObject *ownerObjOrNull = zfnull
            ) const;
    zfauto methodInvoke(
            ZF_IN ZFObject *ownerObjOrNull
            , 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()
            ) const;
    zfbool methodInvokeT(
            ZF_OUT zfauto &ret
            , ZF_OUT_OPT zfstring *errorHint
            , ZF_IN ZFObject *ownerObjOrNull
            , 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()
            ) const;
    zfauto methodInvokeDetail(
            ZF_IN ZFObject *ownerObjOrNull
            , ZF_IN const ZFCoreArray<zfauto> &params
            , ZF_OUT_OPT zfbool *success = zfnull
            , ZF_OUT_OPT zfstring *errorHint = zfnull
            ) const;

    zfbool methodInvokeCheck(
            ZF_IN ZFObject *ownerObjOrNull
            , ZF_OUT_OPT zfstring *errorHint = zfnull
            ) const;

    ZFMethodGenericInvoker methodGenericInvokerOrig(void) const;

    inline zfbool preferGenericInvoker(void) const {
        return ZFBitTest(_stateFlags, _stateFlags_preferGenericInvoker);
    }
 
    // ============================================================
    // class member type
public:
    inline const ZFClass *ownerClass(void) const {
        return _ownerClass;
    }

    inline const ZFProperty *ownerProperty(void) const {
        return _ownerProperty;
    }

    inline ZFMethodAccessType methodAccessType(void) const {
        return (ZFMethodAccessType)_methodAccessType;
    }

    inline zfbool isPublic(void) const {return (ZFMethodAccessType)_methodAccessType == ZFMethodAccessTypePublic;}
    inline zfbool isProtected(void) const {return (ZFMethodAccessType)_methodAccessType == ZFMethodAccessTypeProtected;}
    inline zfbool isPrivate(void) const {return (ZFMethodAccessType)_methodAccessType == ZFMethodAccessTypePrivate;}

    inline ZFMethodType methodType(void) const {
        return (ZFMethodType)_methodType;
    }

    inline zfbool isNormal(void) const {return (ZFMethodType)_methodType == ZFMethodTypeNormal;}
    inline zfbool isStatic(void) const {return (ZFMethodType)_methodType == ZFMethodTypeStatic;}
    inline zfbool isVirtual(void) const {return (ZFMethodType)_methodType == ZFMethodTypeVirtual;}
 
    // ============================================================
    // func type
public:
    inline zfbool isFuncType(void) const {
        return (_ownerClass == zfnull);
    }

    inline const zfstring &methodNamespace(void) const {
        return _methodNamespace;
    }
 
    // ============================================================
    // other
public:
    inline zfbool isInternal(void) const {
        return ZFBitTest(_stateFlags, _stateFlags_isInternal);
    }

    inline zfbool isInternalPrivate(void) const {
        return ZFBitTest(_stateFlags, _stateFlags_isInternalPrivate);
    }
 
public:
    static ZFMethod *_ZFP_ZFMethodRegister(
            ZF_IN zfbool isUserRegister
            , ZF_IN zfbool isDynamicRegister
            , ZF_IN ZFObject *dynamicRegisterUserData
            , ZF_IN ZFFuncAddrType methodInvoker
            , ZF_IN ZFMethodGenericInvoker methodGenericInvoker
            , ZF_IN ZFMethodType methodType
            , ZF_IN const ZFClass *ownerClass
            , ZF_IN ZFMethodAccessType methodAccessType
            , ZF_IN const zfstring &methodNamespace
            , ZF_IN const zfstring &methodName
            , ZF_IN const zfstring &returnTypeId
            , ZF_IN const _ZFP_ZFMethodMP &mp
            );
    static void _ZFP_ZFMethodUnregister(ZF_IN const ZFMethod *method);
 
    ZFMethod *_ZFP_ZFMethod_removeConst(void) const {
        return const_cast<ZFMethod *>(this);
    }
    _ZFP_ZFMethodPrivate *_ZFP_ZFMethod_extInit(void);
    inline _ZFP_ZFMethodPrivate *_ZFP_ZFMethod_ext(void) const {
        return _ext;
    }
    inline ZFSigName *_ZFP_ZFMethod_paramTypeIdList(void) const {
        return _paramBuf;
    }
    inline ZFSigName *_ZFP_ZFMethod_paramNameList(void) const {
        return _paramBuf + ZFMETHOD_MAX_PARAM;
    }
    void _ZFP_ZFMethod_ownerProperty(ZF_IN const ZFProperty *ownerProperty) const {
        this->_ZFP_ZFMethod_removeConst()->_ownerProperty = ownerProperty;
    }
 
    void _ZFP_ZFMethodImplReplace_invoke(ZF_IN const ZFArgs &zfargs);
    void _ZFP_ZFMethodImplReplace_attach(ZF_IN const ZFListener &impl);
    void _ZFP_ZFMethodImplReplace_detach(ZF_IN const ZFListener &impl);
 
private:
    enum {
        _stateFlags_isInternal = 1 << 0,
        _stateFlags_isInternalPrivate = 1 << 1,
        _stateFlags_isUserRegister = 1 << 2,
        _stateFlags_isDynamicRegister = 1 << 3,
        _stateFlags_preferGenericInvoker = 1 << 4,
    };
private:
    zfuint _refCount;
    zfuint _stateFlags;
    ZFObject *_methodUserData;
    ZFSigName _methodId;
    _ZFP_ZFMethodPrivate *_ext;
    ZFFuncAddrType _methodInvoker;
    ZFMethodGenericInvoker _methodGenericInvoker;
    ZFSigName _methodName;
    ZFSigName _returnTypeId;
    ZFSigName *_paramBuf;
    ZFListener *_paramDefaultValueCallbackList;
    zfbyte _paramCount;
    zfbyte _paramCountMin;
    zfbyte _paramDefaultBeginIndex;
 
    // for class member type
    zfbyte _methodAccessType; // ZFMethodAccessType
    zfbyte _methodType; // ZFMethodType
    const ZFClass *_ownerClass;
    const ZFProperty *_ownerProperty;
 
    // for func type
    ZFSigName _methodNamespace;
};
 
// ============================================================
extern ZFLIB_ZFCore void _ZFP_ZFMethodDataHolderInit(void);
 
zfclassLikePOD ZFLIB_ZFCore _ZFP_ZFMethodRegisterHolder {
public:
    _ZFP_ZFMethodRegisterHolder(
            ZF_IN zfbool isUserRegister
            , ZF_IN zfbool isDynamicRegister
            , ZF_IN ZFObject *dynamicRegisterUserData
            , ZF_IN ZFFuncAddrType methodInvoker
            , ZF_IN ZFMethodGenericInvoker methodGenericInvoker
            , ZF_IN ZFMethodType methodType
            , ZF_IN const ZFClass *ownerClass
            , ZF_IN ZFMethodAccessType methodAccessType
            , ZF_IN const zfstring &methodNamespace
            , ZF_IN const zfstring &methodName
            , ZF_IN const zfstring &returnTypeId
            , ZF_IN const _ZFP_ZFMethodMP &mp
            );
    ~_ZFP_ZFMethodRegisterHolder(void);
public:
    ZFMethod *method;
};
 
// ============================================================
extern ZFLIB_ZFCore void ZFMethodGetAllT(ZF_IN_OUT ZFCoreArray<const ZFMethod *> &ret);
inline ZFCoreArray<const ZFMethod *> ZFMethodGetAll(void) {
    ZFCoreArray<const ZFMethod *> ret;
    ZFMethodGetAllT(ret);
    return ret;
}
 
// ============================================================
/* ZFMETHOD_MAX_PARAM */
extern ZFLIB_ZFCore const ZFMethod *ZFMethodForName(
        ZF_IN const zfstring &classNameOrNamespace
        , ZF_IN const zfstring &methodName
        );
extern ZFLIB_ZFCore const ZFMethod *ZFMethodForName(
        ZF_IN const zfstring &classNameOrNamespace
        , ZF_IN const zfstring &methodName
        , ZF_IN_OPT const zfchar *paramTypeId0
        , ZF_IN_OPT const zfchar *paramTypeId1 = zfnull
        , ZF_IN_OPT const zfchar *paramTypeId2 = zfnull
        , ZF_IN_OPT const zfchar *paramTypeId3 = zfnull
        , ZF_IN_OPT const zfchar *paramTypeId4 = zfnull
        , ZF_IN_OPT const zfchar *paramTypeId5 = zfnull
        , ZF_IN_OPT const zfchar *paramTypeId6 = zfnull
        , ZF_IN_OPT const zfchar *paramTypeId7 = zfnull
        );

extern ZFLIB_ZFCore void ZFMethodForNameGetAllT(
        ZF_IN_OUT ZFCoreArray<const ZFMethod *> &ret
        , ZF_IN const zfstring &classNameOrNamespace
        , ZF_IN const zfstring &methodName
        );
inline ZFCoreArray<const ZFMethod *> ZFMethodForNameGetAll(
        ZF_IN const zfstring &classNameOrNamespace
        , ZF_IN const zfstring &methodName
        ) {
    ZFCoreArray<const ZFMethod *> ret;
    ZFMethodForNameGetAllT(ret, classNameOrNamespace, methodName);
    return ret;
}
 
// ============================================================
extern ZFLIB_ZFCore const ZFMethod *ZFMethodAlias(
        ZF_IN const ZFMethod *method
        , ZF_IN const zfstring &aliasName
        );
extern ZFLIB_ZFCore void ZFMethodAliasRemove(ZF_IN const ZFMethod *aliasMethod);
 
// ============================================================
extern ZFLIB_ZFCore ZFListener ZFMethodImplReplace(
        ZF_IN const ZFMethod *method
        , ZF_IN const ZFListener &impl
        );
extern ZFLIB_ZFCore void ZFMethodImplRestore(
        ZF_IN const ZFMethod *method
        , ZF_IN const ZFListener &impl
        );
 
ZF_NAMESPACE_GLOBAL_END
#endif // #ifndef _ZFI_ZFMethod_h_