ZFDynamicInvoker.h

Go to the documentation of this file.

 
#ifndef _ZFI_ZFDynamicInvoker_h_
#define _ZFI_ZFDynamicInvoker_h_
 
#include "ZFObjectCore.h"
#include "ZFObjectRetain.h"
ZF_NAMESPACE_GLOBAL_BEGIN
 
// ============================================================
zfabstract ZFLIB_ZFCore ZFDI_WrapperBase : zfextend ZFObject {
    ZFOBJECT_DECLARE_ABSTRACT(ZFDI_WrapperBase, ZFObject)
    ZFALLOC_CACHE_RELEASE_ABSTRACT({
        cache->zfv(zfnull);
    })
 
public:
    virtual void zfv(ZF_IN const zfchar *zfv) zfpurevirtual;
    virtual const zfchar *zfv(void) zfpurevirtual;
 
public:
    zfoverride
    virtual zfidentity objectHashImpl(void) {
        return zfidentityCalcString(this->zfv());
    }
    zfoverride
    virtual ZFCompareResult objectCompareImpl(ZF_IN ZFObject *anotherObj) {
        zfself *ref = zfcast(zfself *, anotherObj);
        if(ref != zfnull) {
            return ZFComparerDefault(this->zfv(), ref->zfv());
        }
        else {
            return ZFCompareUncomparable;
        }
    }
    zfoverride
    virtual inline zfbool objectIsInternal(void) {return zftrue;}
    zfoverride
    virtual inline zfbool objectIsInternalPrivate(void) {return zftrue;}
    zfoverride
    virtual void objectInfoImpl(ZF_IN_OUT zfstring &ret) {
        ret += this->zfv();
    }
protected:
    zfoverride
    virtual void objectOnInit(void) {zfsuper::objectOnInit();}
    virtual void objectOnInit(ZF_IN const zfchar *zfv) {this->zfv(zfv);}
};

zfclass ZFLIB_ZFCore ZFDI_Wrapper : zfextend ZFDI_WrapperBase {
    ZFOBJECT_DECLARE(ZFDI_Wrapper, ZFDI_WrapperBase)
public:
    zfoverride
    virtual void zfv(ZF_IN const zfchar *zfv) {
        this->_ZFP_zfv = zfv;
    }
    zfoverride
    virtual const zfchar *zfv(void) {return this->_ZFP_zfv;}
private:
    zfstring _ZFP_zfv;
};

zfclass ZFLIB_ZFCore ZFDI_WrapperRaw : zfextend ZFDI_WrapperBase {
    ZFOBJECT_DECLARE_WITH_CUSTOM_CTOR(ZFDI_WrapperRaw, ZFDI_WrapperBase)
public:
    zfoverride
    virtual void zfv(ZF_IN const zfchar *zfv) {
        if(zfv) {
            this->_ZFP_zfv = zfv;
        }
        else {
            this->_ZFP_zfv = "";
        }
    }
    zfoverride
    virtual const zfchar *zfv(void) {return this->_ZFP_zfv;}
private:
    const zfchar *_ZFP_zfv;
protected:
    ZFDI_WrapperRaw(void) : _ZFP_zfv("") {}
};
 
// ============================================================
extern ZFLIB_ZFCore const zfchar *ZFDI_toString(ZF_IN ZFObject *obj);

extern ZFLIB_ZFCore zfbool ZFDI_toNumberT(ZF_OUT zfdouble &ret, ZF_IN ZFObject *obj);
inline zfdouble ZFDI_toNumber(ZF_IN ZFObject *obj) {
    zfdouble ret = -1;
    if(ZFDI_toNumberT(ret, obj)) {
        return ret;
    }
    else {
        return -1;
    }
}

extern ZFLIB_ZFCore void ZFDI_paramInfoT(
        ZF_IN_OUT zfstring &ret
        , ZF_IN const ZFArgs &zfargs
        );
inline zfstring ZFDI_paramInfo(ZF_IN const ZFArgs &zfargs) {
    zfstring ret;
    ZFDI_paramInfoT(ret, zfargs);
    return ret;
}

inline zfindex ZFDI_paramCount(ZF_IN const ZFArgs &zfargs) {
    zfindex paramCount = 0;
    while(paramCount < ZFMETHOD_MAX_PARAM && zfargs.paramAt(paramCount) != ZFMP_DEF()) {
        ++paramCount;
    }
    return paramCount;
}

extern ZFLIB_ZFCore void ZFDI_invoke(
        ZF_IN_OUT const ZFArgs &zfargs
        , ZF_IN const zfstring &name
        , ZF_IN_OPT zfbool convStr = zffalse
        );

extern ZFLIB_ZFCore void ZFDI_alloc(
        ZF_IN_OUT const ZFArgs &zfargs
        , ZF_IN const ZFClass *cls
        , ZF_IN_OPT zfbool convStr = zffalse
        );
 
// ============================================================
extern ZFLIB_ZFCore zfbool ZFDI_objectFromString(
        ZF_OUT zfauto &ret
        , ZF_IN const zfstring &typeId
        , ZF_IN const zfchar *src
        , ZF_IN_OPT zfindex srcLen = zfindexMax()
        , ZF_OUT_OPT zfstring *errorHint = zfnull
        );

extern ZFLIB_ZFCore zfbool ZFDI_implicitConvertT(
        ZF_OUT zfauto &ret
        , ZF_IN const zfstring &desiredTypeId
        , ZF_IN ZFObject *value
        , ZF_OUT_OPT zfstring *errorHint = zfnull
        );
inline zfauto ZFDI_implicitConvert(
        ZF_IN const zfstring &desiredTypeId
        , ZF_IN ZFObject *value
        , ZF_OUT_OPT zfstring *errorHint = zfnull
        ) {
    zfauto ret;
    if(ZFDI_implicitConvertT(ret, desiredTypeId, value, errorHint)) {
        return ret;
    }
    else {
        return zfnull;
    }
}
 
// ============================================================
/* ZFMETHOD_MAX_PARAM */
extern ZFLIB_ZFCore zfauto ZFInvoke(
        ZF_IN const zfstring &name
        );
extern ZFLIB_ZFCore zfauto ZFInvoke(
        ZF_IN const zfstring &name
        , 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()
        );
extern ZFLIB_ZFCore zfbool ZFInvokeT(
        ZF_OUT zfauto &ret
        , ZF_OUT_OPT zfstring *errorHint
        , ZF_IN const zfstring &name
        , 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()
        );
extern ZFLIB_ZFCore zfauto ZFInvokeDetail(
        ZF_IN const zfstring &name
        , ZF_IN const ZFCoreArray<zfauto> &params
        , ZF_OUT_OPT zfbool *success = zfnull
        , ZF_OUT_OPT zfstring *errorHint = zfnull
        );
 
// ============================================================
zfclassFwd ZFOutput;
extern ZFLIB_ZFCore ZFCoreArray<ZFOutput> &ZFDI_errorCallbacks(void);
 
ZF_NAMESPACE_GLOBAL_END
#endif // #ifndef _ZFI_ZFDynamicInvoker_h_