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
 
// ============================================================
zfclass ZFLIB_ZFCore ZFDI_Wrapper : zfextend ZFObject {
    ZFOBJECT_DECLARE(ZFDI_Wrapper, ZFObject)
 
public:
    typedef enum {
        TypeString, 
        TypeInt, 
        TypeFloat, 
    } ValueType;
private:
    zfstring _zfvString;
    ValueType _zfvType;
    zfflags _zfvValid;
    zflong _zfvInt;
    zfdouble _zfvFloat;
 
public:
    ValueType valueType(void) {return _zfvType;}
public:
    const zfstring &valueString(void) {
        switch(_zfvType) {
            case TypeString:
                return _zfvString;
            case TypeInt:
                if(!_zfvString) {
                    zfsFromIntT(_zfvString, _zfvInt);
                }
                return _zfvString;
            case TypeFloat:
                if(!_zfvString) {
                    zfsFromFloatT(_zfvString, _zfvFloat);
                }
                return _zfvString;
            default:
                ZFCoreCriticalShouldNotGoHere();
                return _zfvString;
        }
    }

    zfbool valueIntT(ZF_OUT zflong &ret) {
        switch(_zfvType) {
            case TypeString:
                if(!ZFBitTest(_zfvValid, 1 << TypeInt)) {
                    if(!zfsToIntT(_zfvInt, _zfvString, _zfvString.length())) {
                        return zffalse;
                    }
                    ZFBitSet(_zfvValid, 1 << TypeInt);
                }
                ret = _zfvInt;
                return zftrue;
            case TypeInt:
                ret = _zfvInt;
                return zftrue;
            case TypeFloat:
                if(!ZFBitTest(_zfvValid, 1 << TypeInt)) {
                    if(!zffloatIsInt(_zfvFloat)) {
                        return zffalse;
                    }
                    _zfvInt = (zflong)_zfvFloat;
                    ZFBitSet(_zfvValid, 1 << TypeInt);
                }
                ret = _zfvInt;
                return zftrue;
            default:
                ZFCoreCriticalShouldNotGoHere();
                return zffalse;
        }
    }

    zflong valueInt(void) {
        zflong ret = 0;
        this->valueIntT(ret);
        return ret;
    }

    zfbool valueFloatT(ZF_OUT zfdouble &ret) {
        switch(_zfvType) {
            case TypeString:
                if(!ZFBitTest(_zfvValid, 1 << TypeFloat)) {
                    if(!zfsToFloatT(_zfvFloat, _zfvString, _zfvString.length())) {
                        return zffalse;
                    }
                    ZFBitSet(_zfvValid, 1 << TypeFloat);
                }
                ret = _zfvFloat;
                return zftrue;
            case TypeInt:
                if(!ZFBitTest(_zfvValid, 1 << TypeFloat)) {
                    _zfvFloat = (zfdouble)_zfvInt;
                    ZFBitSet(_zfvValid, 1 << TypeFloat);
                }
                ret = _zfvFloat;
                return zftrue;
            case TypeFloat:
                ret = _zfvFloat;
                return zftrue;
            default:
                ZFCoreCriticalShouldNotGoHere();
                return zffalse;
        }
    }

    zfdouble valueFloat(void) {
        zfdouble ret = 0;
        this->valueFloatT(ret);
        return ret;
    }
public:
    void value(ZF_IN const zfstring &v) {
        _zfvType = TypeString;
        _zfvString = v;
        _zfvValid = 0;
    }

    void value(ZF_IN const zflong &v) {
        _zfvType = TypeInt;
        _zfvInt = v;
        _zfvValid = 0;
    }

    void value(ZF_IN const zfdouble &v) {
        _zfvType = TypeFloat;
        _zfvFloat = v;
        _zfvValid = 0;
    }
 
public:
    zfoverride
    virtual zfidentity objectHashImpl(void) {
        switch(_zfvType) {
            case TypeString:
                return zfidentityHash((zfidentity)_zfvType, zfidentityCalcString(_zfvString));
            case TypeInt:
                return zfidentityHash((zfidentity)_zfvType, zfidentityCalc(_zfvInt));
            case TypeFloat:
                return zfidentityHash((zfidentity)_zfvType, zfidentityCalc(_zfvFloat));
            default:
                ZFCoreCriticalShouldNotGoHere();
                return zfidentityInvalid();
        }
    }
    zfoverride
    virtual ZFCompareResult objectCompareImpl(ZF_IN ZFObject *anotherObj) {
        zfself *ref = zfcast(zfself *, anotherObj);
        if(ref != zfnull && _zfvType == ref->_zfvType) {
            switch(_zfvType) {
                case TypeString:
                    return _zfvString == ref->_zfvString ? ZFCompareEqual : ZFCompareUncomparable;
                case TypeInt:
                    return _zfvInt == ref->_zfvInt ? ZFCompareEqual : ZFCompareUncomparable;
                case TypeFloat:
                    return _zfvFloat == ref->_zfvFloat ? ZFCompareEqual : ZFCompareUncomparable;
                default:
                    ZFCoreCriticalShouldNotGoHere();
                    return ZFCompareUncomparable;
            }
        }
        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) {
        if(ret.capacity() != 0) {
            ret += this->valueString();
        }
        else {
            ret = this->valueString().sharedCopy();
        }
    }
protected:
    zfoverride
    virtual void objectOnInit(void) {zfsuper::objectOnInit();}
    virtual void objectOnInit(ZF_IN const zfstring &v) {this->value(v);}
    virtual void objectOnInit(ZF_IN const zflong &v) {this->value(v);}
    virtual void objectOnInit(ZF_IN const zfdouble &v) {this->value(v);}
};
 
// ============================================================
extern ZFLIB_ZFCore zfstring 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 ZFClass *cls
        , ZF_IN const zfchar *src
        , ZF_IN_OPT zfindex srcLen = zfindexMax()
        , ZF_OUT_OPT zfstring *errorHint = zfnull
        );
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
        );
 
// ============================================================
/* 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_