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->methodInvoker()) { \
            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_MtdGII<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_MtdM_EMPTY(...)
#define _ZFP_MtdM_EXPAND(...) __VA_ARGS__
#define _ZFP_MtdP_EXPAND(...) __VA_ARGS__
#define _ZFP_MtdD_EXPAND(...) __VA_ARGS__
#define ZFMP_IN(ParamType, paramName) \
    _ZFP_MtdM_EXPAND, ParamType, paramName, _ZFP_MtdM_EMPTY, _ZFP_ZFMethodNoDefaultParam

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

#define ZFMP_OUT(ParamType, paramName) \
    _ZFP_MtdM_EXPAND, ParamType, paramName, _ZFP_MtdM_EMPTY, _ZFP_ZFMethodNoDefaultParam

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

#define ZFMP_IN_OUT(ParamType, paramName) \
    _ZFP_MtdM_EXPAND, ParamType, paramName, _ZFP_MtdM_EMPTY, _ZFP_ZFMethodNoDefaultParam

#define ZFMP_IN_OUT_OPT(ParamType, paramName, DefaultValue) \
    _ZFP_MtdM_EXPAND, ParamType, paramName, _ZFP_MtdM_EXPAND, _ZFP_ZFMethodDefaultParam(DefaultValue)
 
#define _ZFP_ZFMP_DUMMY() \
    _ZFP_MtdM_EMPTY, ParamType, paramName, _ZFP_MtdM_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_ZFMethodPrivateExt;
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 invoker
            , 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 this->_ZFP_ZFMethod_methodId.sigId();
    }

    inline zfbool isUserRegister(void) const {
        return this->_ZFP_ZFMethod_isUserRegister;
    }

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

    void userRegisterUserData(ZF_IN ZFObject *userData) const;
    inline zfbool isDynamicRegister(void) const {
        return this->_ZFP_ZFMethod_isDynamicRegister;
    }

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

    inline const zfstring &methodName(void) const {
        return this->_ZFP_ZFMethod_methodName;
    }

    inline const zfstring &returnTypeId(void) const {
        return this->_ZFP_ZFMethod_returnTypeId;
    }

    inline zfindex paramCount(void) const {
        return (zfindex)this->_ZFP_ZFMethod_paramCount;
    }

    inline zfindex paramCountMin(void) const {
        return (zfindex)this->_ZFP_ZFMethod_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];
    }

    const ZFListener &paramDefaultValueCallbackAt(ZF_IN zfindex index) const;
    zfauto paramDefaultValueAt(ZF_IN zfindex index) const;
    inline zfindex paramDefaultBeginIndex(void) const {
        return (this->_ZFP_ZFMethod_paramDefaultBeginIndex == (zfuint)-1 ? zfindexMax() : (zfindex)this->_ZFP_ZFMethod_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 this->_ZFP_ZFMethod_invoker;
    }

    void methodInvoker(ZF_IN ZFFuncAddrType methodInvoker) const;
    ZFFuncAddrType methodInvokerOrig(void) const;

    inline ZFMethodGenericInvoker methodGenericInvoker(void) const {
        return this->_ZFP_ZFMethod_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;

    void methodGenericInvoker(ZF_IN ZFMethodGenericInvoker methodGenericInvoker) const;
 
    // ============================================================
    // class member type
public:
    inline const ZFClass *ownerClass(void) const {
        return this->_ZFP_ZFMethod_ownerClass;
    }

    inline const ZFProperty *ownerProperty(void) const {
        return this->_ZFP_ZFMethod_ownerProperty;
    }

    inline ZFMethodAccessType methodAccessType(void) const {
        return (ZFMethodAccessType)this->_ZFP_ZFMethod_accessType;
    }

    inline zfbool isPublic(void) const {return (ZFMethodAccessType)this->_ZFP_ZFMethod_accessType == ZFMethodAccessTypePublic;}
    inline zfbool isProtected(void) const {return (ZFMethodAccessType)this->_ZFP_ZFMethod_accessType == ZFMethodAccessTypeProtected;}
    inline zfbool isPrivate(void) const {return (ZFMethodAccessType)this->_ZFP_ZFMethod_accessType == ZFMethodAccessTypePrivate;}

    inline ZFMethodType methodType(void) const {
        return (ZFMethodType)this->_ZFP_ZFMethod_methodType;
    }

    inline zfbool isNormal(void) const {return (ZFMethodType)this->_ZFP_ZFMethod_methodType == ZFMethodTypeNormal;}
    inline zfbool isStatic(void) const {return (ZFMethodType)this->_ZFP_ZFMethod_methodType == ZFMethodTypeStatic;}
    inline zfbool isVirtual(void) const {return (ZFMethodType)this->_ZFP_ZFMethod_methodType == ZFMethodTypeVirtual;}
 
    // ============================================================
    // func type
public:
    inline zfbool isFuncType(void) const {
        return (this->_ZFP_ZFMethod_ownerClass == zfnull);
    }

    inline const zfstring &methodNamespace(void) const {
        return this->_ZFP_ZFMethod_methodNamespace;
    }
 
    // ============================================================
    // other
public:
    inline zfbool isInternal(void) const {
        return this->_ZFP_ZFMethod_isInternal;
    }

    inline zfbool isInternalPrivate(void) const {
        return this->_ZFP_ZFMethod_isInternalPrivate;
    }
 
public:
    ZFMethod *_ZFP_ZFMethod_removeConst(void) const {
        return const_cast<ZFMethod *>(this);
    }
 
public:
    inline ZFSigName *_ZFP_ZFMethod_paramTypeIdList(void) const {
        return _ZFP_ZFMethod_paramBuf;
    }
    inline ZFSigName *_ZFP_ZFMethod_paramNameList(void) const {
        return _ZFP_ZFMethod_paramBuf + ZFMETHOD_MAX_PARAM;
    }
 
public:
    // general
    zfuint _ZFP_ZFMethod_refCount;
 
    zfbool _ZFP_ZFMethod_isInternal;
    zfbool _ZFP_ZFMethod_isInternalPrivate;
    zfbool _ZFP_ZFMethod_isUserRegister;
    zfbool _ZFP_ZFMethod_isDynamicRegister;
    zfany _ZFP_ZFMethod_methodUserData;
 
    ZFSigName _ZFP_ZFMethod_methodId;
    _ZFP_ZFMethodPrivateExt *_ZFP_ZFMethod_ext;
 
    ZFFuncAddrType _ZFP_ZFMethod_invoker;
    ZFMethodGenericInvoker _ZFP_ZFMethod_methodGenericInvoker;
    ZFSigName _ZFP_ZFMethod_methodName;
    ZFSigName _ZFP_ZFMethod_returnTypeId;
    zfuint _ZFP_ZFMethod_paramCount;
    zfuint _ZFP_ZFMethod_paramCountMin;
    ZFSigName *_ZFP_ZFMethod_paramBuf;
    ZFListener *_ZFP_ZFMethod_paramDefaultValueCallbackList;
    zfuint _ZFP_ZFMethod_paramDefaultBeginIndex;
 
    // for class member type
    unsigned short /* ZFMethodAccessType */ _ZFP_ZFMethod_accessType;
    unsigned short /* ZFMethodType */ _ZFP_ZFMethod_methodType;
    const ZFClass *_ZFP_ZFMethod_ownerClass;
    const ZFProperty *_ZFP_ZFMethod_ownerProperty;
 
    // for func type
    ZFSigName _ZFP_ZFMethod_methodNamespace;
};
 
// ============================================================
extern ZFLIB_ZFCore void _ZFP_ZFMethodDataHolderInit(void);
extern ZFLIB_ZFCore 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
        );
extern ZFLIB_ZFCore void _ZFP_ZFMethodUnregister(ZF_IN const ZFMethod *method);
 
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);
 
ZF_NAMESPACE_GLOBAL_END
#endif // #ifndef _ZFI_ZFMethod_h_